From 56f7cd1875a988f5cc24aa04ddce8bce8de03a48 Mon Sep 17 00:00:00 2001 From: Patrick Date: Fri, 3 Oct 2025 20:16:11 +0200 Subject: [PATCH] Initial commit --- .gitignore | 2 + .vscode/launch.json | 16 + include/pgpl.h | 27 + include/pgpl/gui.h | 45 + include/pgpl/gui/helpers.h | 55 + include/pgpl/gui/predef.h | 131 + include/pgpl/gui/widgets.h | 96 + include/pgpl/render.h | 8 + include/pgpl/render/color.h | 56 + include/pgpl/render/font.h | 69 + include/pgpl/render/predef.h | 37 + include/pgpl/render/shapes.h | 39 + include/pgpl/render/texture.h | 73 + include/pgpl/thread.h | 46 + include/pgpl/timer.h | 33 + include/pgpl/vector.h | 68 + include/pgpl/window.h | 114 + include/pgpl/window/predef.h | 50 + include/pgpl/window/thread.h | 104 + include/stb/stb_image.h | 7988 +++++++++++++++++ include/stb/stb_truetype.h | 5079 +++++++++++ meson.build | 64 + roboto.ttf | Bin 0 -> 468308 bytes src/gui/gui.c | 125 + src/gui/helpers.c | 187 + src/gui/widgets/button.c | 88 + src/gui/widgets/container.c | 169 + src/gui/widgets/empty.c | 59 + src/gui/widgets/text.c | 65 + src/pgpl.c | 7 + src/render/font.c | 261 + src/render/internal.h | 15 + src/render/shapes.c | 96 + src/render/texture.c | 143 + src/thread.c | 44 + src/timer.c | 48 + src/vector.c | 105 + src/window/internal.h | 24 + src/window/thread.c | 363 + src/window/window-win32.c | 331 + src/window/window-x11.c | 232 + src/window/window.c | 93 + tests/clap/all.h | 17 + tests/clap/audio-buffer.h | 37 + tests/clap/clap.h | 64 + tests/clap/color.h | 20 + tests/clap/entry.h | 136 + tests/clap/events.h | 367 + tests/clap/ext/ambisonic.h | 63 + tests/clap/ext/audio-ports-activation.h | 64 + tests/clap/ext/audio-ports-config.h | 109 + tests/clap/ext/audio-ports.h | 116 + tests/clap/ext/configurable-audio-ports.h | 63 + tests/clap/ext/context-menu.h | 167 + tests/clap/ext/draft/extensible-audio-ports.h | 33 + .../clap/ext/draft/gain-adjustment-metering.h | 34 + tests/clap/ext/draft/mini-curve-display.h | 153 + tests/clap/ext/draft/project-location.h | 108 + tests/clap/ext/draft/resource-directory.h | 88 + tests/clap/ext/draft/scratch-memory.h | 90 + tests/clap/ext/draft/transport-control.h | 66 + tests/clap/ext/draft/triggers.h | 144 + tests/clap/ext/draft/tuning.h | 76 + tests/clap/ext/draft/undo.h | 201 + tests/clap/ext/event-registry.h | 22 + tests/clap/ext/gui.h | 244 + tests/clap/ext/latency.h | 27 + tests/clap/ext/log.h | 33 + tests/clap/ext/note-name.h | 37 + tests/clap/ext/note-ports.h | 79 + tests/clap/ext/param-indication.h | 77 + tests/clap/ext/params.h | 382 + tests/clap/ext/posix-fd-support.h | 49 + tests/clap/ext/preset-load.h | 53 + tests/clap/ext/remote-controls.h | 83 + tests/clap/ext/render.h | 39 + tests/clap/ext/state-context.h | 72 + tests/clap/ext/state.h | 45 + tests/clap/ext/surround.h | 89 + tests/clap/ext/tail.h | 26 + tests/clap/ext/thread-check.h | 72 + tests/clap/ext/thread-pool.h | 66 + tests/clap/ext/timer-support.h | 31 + tests/clap/ext/track-info.h | 66 + tests/clap/ext/voice-info.h | 56 + .../clap/factory/draft/plugin-invalidation.h | 47 + .../factory/draft/plugin-state-converter.h | 99 + tests/clap/factory/plugin-factory.h | 42 + tests/clap/factory/preset-discovery.h | 313 + tests/clap/fixedpoint.h | 16 + tests/clap/host.h | 51 + tests/clap/id.h | 8 + tests/clap/plugin-features.h | 79 + tests/clap/plugin.h | 114 + tests/clap/private/macros.h | 50 + tests/clap/private/std.h | 16 + tests/clap/process.h | 66 + tests/clap/stream.h | 38 + tests/clap/string-sizes.h | 21 + tests/clap/timestamp.h | 11 + tests/clap/universal-plugin-id.h | 26 + tests/clap/version.h | 42 + tests/plugin.cpp | 437 + tests/program.c | 91 + todo.md | 23 + 105 files changed, 22109 insertions(+) create mode 100644 .gitignore create mode 100644 .vscode/launch.json create mode 100644 include/pgpl.h create mode 100644 include/pgpl/gui.h create mode 100644 include/pgpl/gui/helpers.h create mode 100644 include/pgpl/gui/predef.h create mode 100644 include/pgpl/gui/widgets.h create mode 100644 include/pgpl/render.h create mode 100644 include/pgpl/render/color.h create mode 100644 include/pgpl/render/font.h create mode 100644 include/pgpl/render/predef.h create mode 100644 include/pgpl/render/shapes.h create mode 100644 include/pgpl/render/texture.h create mode 100644 include/pgpl/thread.h create mode 100644 include/pgpl/timer.h create mode 100644 include/pgpl/vector.h create mode 100644 include/pgpl/window.h create mode 100644 include/pgpl/window/predef.h create mode 100644 include/pgpl/window/thread.h create mode 100644 include/stb/stb_image.h create mode 100644 include/stb/stb_truetype.h create mode 100644 meson.build create mode 100644 roboto.ttf create mode 100644 src/gui/gui.c create mode 100644 src/gui/helpers.c create mode 100644 src/gui/widgets/button.c create mode 100644 src/gui/widgets/container.c create mode 100644 src/gui/widgets/empty.c create mode 100644 src/gui/widgets/text.c create mode 100644 src/pgpl.c create mode 100644 src/render/font.c create mode 100644 src/render/internal.h create mode 100644 src/render/shapes.c create mode 100644 src/render/texture.c create mode 100644 src/thread.c create mode 100644 src/timer.c create mode 100644 src/vector.c create mode 100644 src/window/internal.h create mode 100644 src/window/thread.c create mode 100644 src/window/window-win32.c create mode 100644 src/window/window-x11.c create mode 100644 src/window/window.c create mode 100644 tests/clap/all.h create mode 100644 tests/clap/audio-buffer.h create mode 100644 tests/clap/clap.h create mode 100644 tests/clap/color.h create mode 100644 tests/clap/entry.h create mode 100644 tests/clap/events.h create mode 100644 tests/clap/ext/ambisonic.h create mode 100644 tests/clap/ext/audio-ports-activation.h create mode 100644 tests/clap/ext/audio-ports-config.h create mode 100644 tests/clap/ext/audio-ports.h create mode 100644 tests/clap/ext/configurable-audio-ports.h create mode 100644 tests/clap/ext/context-menu.h create mode 100644 tests/clap/ext/draft/extensible-audio-ports.h create mode 100644 tests/clap/ext/draft/gain-adjustment-metering.h create mode 100644 tests/clap/ext/draft/mini-curve-display.h create mode 100644 tests/clap/ext/draft/project-location.h create mode 100644 tests/clap/ext/draft/resource-directory.h create mode 100644 tests/clap/ext/draft/scratch-memory.h create mode 100644 tests/clap/ext/draft/transport-control.h create mode 100644 tests/clap/ext/draft/triggers.h create mode 100644 tests/clap/ext/draft/tuning.h create mode 100644 tests/clap/ext/draft/undo.h create mode 100644 tests/clap/ext/event-registry.h create mode 100644 tests/clap/ext/gui.h create mode 100644 tests/clap/ext/latency.h create mode 100644 tests/clap/ext/log.h create mode 100644 tests/clap/ext/note-name.h create mode 100644 tests/clap/ext/note-ports.h create mode 100644 tests/clap/ext/param-indication.h create mode 100644 tests/clap/ext/params.h create mode 100644 tests/clap/ext/posix-fd-support.h create mode 100644 tests/clap/ext/preset-load.h create mode 100644 tests/clap/ext/remote-controls.h create mode 100644 tests/clap/ext/render.h create mode 100644 tests/clap/ext/state-context.h create mode 100644 tests/clap/ext/state.h create mode 100644 tests/clap/ext/surround.h create mode 100644 tests/clap/ext/tail.h create mode 100644 tests/clap/ext/thread-check.h create mode 100644 tests/clap/ext/thread-pool.h create mode 100644 tests/clap/ext/timer-support.h create mode 100644 tests/clap/ext/track-info.h create mode 100644 tests/clap/ext/voice-info.h create mode 100644 tests/clap/factory/draft/plugin-invalidation.h create mode 100644 tests/clap/factory/draft/plugin-state-converter.h create mode 100644 tests/clap/factory/plugin-factory.h create mode 100644 tests/clap/factory/preset-discovery.h create mode 100644 tests/clap/fixedpoint.h create mode 100644 tests/clap/host.h create mode 100644 tests/clap/id.h create mode 100644 tests/clap/plugin-features.h create mode 100644 tests/clap/plugin.h create mode 100644 tests/clap/private/macros.h create mode 100644 tests/clap/private/std.h create mode 100644 tests/clap/process.h create mode 100644 tests/clap/stream.h create mode 100644 tests/clap/string-sizes.h create mode 100644 tests/clap/timestamp.h create mode 100644 tests/clap/universal-plugin-id.h create mode 100644 tests/clap/version.h create mode 100644 tests/plugin.cpp create mode 100644 tests/program.c create mode 100644 todo.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a4fb4fb --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build/ +.cache/ diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..7304b52 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,16 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "type": "lldb", + "request": "launch", + "name": "Launch", + "program": "${workspaceFolder}/build/pgpl_test", + "args": [], + "cwd": "${workspaceFolder}/build" + } + ] +} diff --git a/include/pgpl.h b/include/pgpl.h new file mode 100644 index 0000000..015e3ed --- /dev/null +++ b/include/pgpl.h @@ -0,0 +1,27 @@ +#ifndef PGPL_H +#define PGPL_H + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This initalizes certain values inside of the pgpl library, call this before + * you call any other pgpl function. */ +void pgpl_init(void); + +/* This frees any of the resources allocated by pgpl_init. You may call + * pgpl_init again after calling this function. */ +void pgpl_deinit(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/gui.h b/include/pgpl/gui.h new file mode 100644 index 0000000..1307e1c --- /dev/null +++ b/include/pgpl/gui.h @@ -0,0 +1,45 @@ +#ifndef PGPL_GUI_H +#define PGPL_GUI_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This creates a new GUI instance, the parameters are mostly the same as + * creating a window, however you can also specify a theme which will theme the + * widgets respectively, and app_data, which can be used in callbacks of + * widgets. */ +PGPL_Gui *pgpl_gui_create(const char *title, uint32_t width, uint32_t height, + int32_t x, int32_t y, PGPL_GuiTheme *theme, + void *app_data); + +/* Destroys the GUI object, including all of its widgets by calling their + * destroy method. The internal boolean must be set to true if this is being + * called from inside of the gui event loop.*/ +void pgpl_gui_destroy(PGPL_Gui *gui, bool internal); + +/* This shows the GUI window. If wait is true, this will block until the window + * is closed. */ +void pgpl_gui_run_and_show(PGPL_Gui *gui, bool wait); + +/* Adds the specified widget to be rendered by the GUI. */ +void pgpl_gui_widget_add(PGPL_Gui *gui, PGPL_GuiWidget *widget); + +/* Removes the widget at the specified index. */ +void pgpl_gui_widget_remove(PGPL_Gui *gui, uint32_t index); + +/* Get amount of widgets that the gui contains. */ +uint32_t pgpl_gui_widget_amount(PGPL_Gui *gui); + +/* Gets the widget at the specified index. */ +PGPL_GuiWidget *pgpl_gui_widget_get(PGPL_Gui *gui, uint32_t index); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/gui/helpers.h b/include/pgpl/gui/helpers.h new file mode 100644 index 0000000..0d40863 --- /dev/null +++ b/include/pgpl/gui/helpers.h @@ -0,0 +1,55 @@ +#ifndef PGPL_GUI_HELPERS_H +#define PGPL_GUI_HELPERS_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This function basically subtracts margin, border and padding from the + * max_width and max_height, and then return that through the width and height + * pointers. */ +void pgpl_gui_widget_max_content_size(PGPL_GuiWidget *widget, + PGPL_GuiTheme *theme, double *width, + double *height, double max_width, + double max_height); + +/* This function lets you configure a theme with just a base_color, which in + * this case is the brightest color that should be used (text, active), a font + * size for the content and a font. This will calculate the other colors, + * margin, border, padding and other font sizes based on those values. */ +void pgpl_gui_theme_configure(PGPL_GuiTheme *theme, PGPL_Color base_color, + double content_font_size, PGPL_Font *font); + +/* This will do a full render on a widget, it will account for it's offset, if + * it has a border or background, it's margin, border and padding sizes and also + * if it expands on the x and y axis. It then calls the widgets render function + * at the correct x and y offset. */ +void pgpl_gui_widget_render_full(PGPL_GuiWidget *widget, + PGPL_Renderer *renderer, PGPL_GuiTheme *theme, + double x, double y, double max_width, + double max_height); + +/* Checks if x and y lie within the visible bounds of a widget, accounting for + * margin, border and padding and returns true or false. */ +bool pgpl_gui_widget_within_bounds(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double widget_x, double widget_y, + double max_width, double max_height, + double x, double y); + +/* This configures all of the widget properties that should be configurable by + * the user. Check the PGPL_GuiWidget struct comment for more info. */ +void pgpl_gui_widget_configure(PGPL_GuiWidget *widget, double offset_x, + double offset_y, bool expand_x, bool expand_y, + bool border, bool background, + PGPL_GuiFontSize font_size, + PGPL_GuiTheme *theme_override, + bool use_theme_override, bool ignore_margin, + bool ignore_border, bool ignore_padding); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/gui/predef.h b/include/pgpl/gui/predef.h new file mode 100644 index 0000000..59124ae --- /dev/null +++ b/include/pgpl/gui/predef.h @@ -0,0 +1,131 @@ +#ifndef PGPL_GUI_PREDEF_H +#define PGPL_GUI_PREDEF_H + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Predefinition of some structs. */ +typedef struct PGPL_GuiWidget PGPL_GuiWidget; +typedef struct PGPL_Gui PGPL_Gui; + +/* These are the enum values for the GUI colors. This helps select a different + * color from the theme if a widget is currently active, hovered over, or in a + * default state. */ +typedef enum PGPL_GuiStatusColor { + PGPL_GUI_STATUS_COLOR_NORMAL, + PGPL_GUI_STATUS_COLOR_HOVER, + PGPL_GUI_STATUS_COLOR_ACTIVE +} PGPL_GuiStatusColor; + +/* This controls what font size from the theme should be used. There are three + * different types. */ +typedef enum PGPL_GuiFontSize { + PGPL_GUI_FONT_SIZE_TITLE, + PGPL_GUI_FONT_SIZE_HEADING, + PGPL_GUI_FONT_SIZE_CONTENT +} PGPL_GuiFontSize; + +/* This is the struct for the themes. This controls the colors, font sizes, font + * and many more settings that widgets in a GUI render with. You can use the + * helper function pgpl_gui_theme_configure to easily configure such a theme + * struct. */ +typedef struct PGPL_GuiTheme { + /* Color for the text and borders, array of 3 colors to support all values + * from PGPL_GuiStatusColor. */ + PGPL_Color text_color[3]; + /* Color for the background of widgets, array of 3 colors to support all + * values from PGPL_GuiStatusColor. */ + PGPL_Color widget_background_color[3]; + /* Color for the background of a GUI. */ + PGPL_Color background_color; + /* Controls the margin of the widgets. */ + PGPL_Rectangle margin; + /* Controls the border of the widgets. */ + PGPL_Rectangle border; + /* Controls the padding of the widgets. */ + PGPL_Rectangle padding; + /* Controls the font size of the widgets, this is an array of three so that it + * can support all values from PGPL_GuiFontSize. */ + double font_size[3]; + /* The font of the theme. */ + PGPL_Font *font; +} PGPL_GuiTheme; + +/* This is the struct for the individual widgets. This can be used to create + * custom widgets as well. Do note that if you create a custom struct for your + * widget, you need to ensure that the first attribute of said struct is of type + * PGPL_GuiWidget, so that other containers and the gui itself can call its + * methods and read its attributes. */ +struct PGPL_GuiWidget { + /* This should be a unique string, often the name of the struct, so that the + * widget type can be identified. */ + const char *id; + /* This is the rendering offset of the widget. */ + double offset_x, offset_y; + /* expand_x and expand_y determine if the widget should expand in the x and y + * direction when being rendered. */ + bool expand_x, expand_y; + /* This determines if the border and background of the widget should be + * rendered or not. */ + bool border, background; + /* This picks out which font size from the theme to use. */ + PGPL_GuiFontSize font_size; + /* This picks out which color from the theme to use. */ + PGPL_GuiStatusColor gui_color; + /* This is the theme that should be used instead of the main theme. Note that + * this theme should propagate to any possible child widgets as well. */ + PGPL_GuiTheme theme_override; + /* This determines if the override theme should even be used. If this is + * false, the theme_override is simply ignored. */ + bool use_theme_override; + /* These attributes determine whether or not margin, border and padding sizes + * respectively should be ignored when rendering. */ + bool ignore_margin, ignore_border, ignore_padding; + /* This returns the size of the content of a widget. This should NOT include + * any margin, padding or border size. */ + void (*get_content_size)(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double *width, double *height, double max_width, + double max_height); + /* This renders the content of the widget. Note that the margin, border, + * padding, background and offset of the widget must be accounted for BEFORE + * calling this function. For ease, you can use the + * pgpl_gui_widget_render_full function to automatically take care of all of + * those things for you. */ + void (*render_content)(PGPL_GuiWidget *widget, PGPL_Renderer *renderer, + PGPL_GuiTheme *theme, double x, double y, + double max_width, double max_height); + /* This should get called for every event that is not a render or close event. + * Note that the x and y values should be called with the widgets offset + * pre-included. */ + void (*event)(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, PGPL_Gui *gui, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data, double x, double y, + double max_width, double max_height); + /* This should destroy the widget, freeing all of its resources and also call + * the destroy method on all of its potential child widgets. */ + void (*destroy)(PGPL_GuiWidget *widget); +}; + +/* This is the struct for the gui itself. Do not modify it's mutex and the + * widgets vector. The app_data value is used for event callbacks. */ +struct PGPL_Gui { + PGPL_WindowThread *window_thread; + PGPL_GuiTheme theme; + PGPL_Vector *widgets; + void *app_data; + PGPL_Mutex *mutex; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/gui/widgets.h b/include/pgpl/gui/widgets.h new file mode 100644 index 0000000..57d002d --- /dev/null +++ b/include/pgpl/gui/widgets.h @@ -0,0 +1,96 @@ +#ifndef PGPL_GUI_WIDGETS_H +#define PGPL_GUI_WIDGETS_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* These are the two directions a PGPL_GuiContainerLayout can place widgets in. + * You can combine multiple of these to recreate a grid layout. */ +typedef enum PGPL_GuiContainerLayoutDirection { + PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL, + PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_HORIZONTAL +} PGPL_GuiContainerLayoutDirection; + +/* This is the PGPL_GuiContainerLayout, it places it's widgets along a single + * direction, see PGPL_GuiContainerLayoutDirection for more details on that. Do + * not modify the mutex and widgets vector in this struct. */ +typedef struct PGPL_GuiContainerLayout { + PGPL_GuiWidget parent; + PGPL_Vector *widgets; + PGPL_GuiContainerLayoutDirection direction; + PGPL_Mutex *mutex; +} PGPL_GuiContainerLayout; + +/* This creates a new container layout instance with the specified direction. */ +PGPL_GuiContainerLayout * +pgpl_gui_container_layout_create(PGPL_GuiContainerLayoutDirection direction); + +/* This adds a widget to a container layout. */ +void pgpl_gui_container_layout_widget_add( + PGPL_GuiContainerLayout *container_layout, PGPL_GuiWidget *widget); + +/* This returns a writeable pointer to the widget at the specified index in the + * container_layout. */ +PGPL_GuiWidget * +pgpl_gui_container_layout_widget_get(PGPL_GuiContainerLayout *container_layout, + uint32_t index); + +/* This deletes the widget at the specified index from the container layout. */ +void pgpl_gui_container_layout_widget_delete( + PGPL_GuiContainerLayout *container_layout, uint32_t index); + +/* This returns the amount of widgets in a container layout. */ +uint32_t pgpl_gui_container_layout_widget_amount( + PGPL_GuiContainerLayout *container_layout); + +/* This destroys a container layout, and calls the destroy method on all of it's + * child widgets. */ +void pgpl_gui_container_layout_destroy( + PGPL_GuiContainerLayout *container_layout); + +/* The struct for a PGPL_GuiTextWidget, the text variable is the string to be + * displayed. */ +typedef struct PGPL_GuiTextWidget { + PGPL_GuiWidget parent; + const char *text; +} PGPL_GuiTextWidget; + +/* Creates a new text widget. */ +PGPL_GuiTextWidget *pgpl_gui_text_widget_create(const char *text); + +/* Destroys a text widget. */ +void pgpl_gui_text_widget_destroy(PGPL_GuiTextWidget *text_widget); + +/* The struct for a PGPL_GuiButtonWidget, the text variable is the string to be + * displayed. The click_callback variable gets called with the gui instances + * app_data parameter. */ +typedef struct PGPL_GuiButtonWidget { + PGPL_GuiWidget parent; + const char *text; + void (*click_callback)(void *app_data); +} PGPL_GuiButtonWidget; + +/* Creates a new button widget. */ +PGPL_GuiButtonWidget * +pgpl_gui_button_widget_create(const char *text, + void (*click_callback)(void *app_data)); + +/* Destroys a button widget. */ +void pgpl_gui_button_widget_destroy(PGPL_GuiButtonWidget *button_widget); + +/* Creates a new empty widget. This is very useful to create spacers for + * container layouts. */ +PGPL_GuiWidget *pgpl_gui_empty_widget_create(void); + +/* Destroys a empty widget. */ +void pgpl_gui_empty_widget_destroy(PGPL_GuiWidget *empty_widget); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/render.h b/include/pgpl/render.h new file mode 100644 index 0000000..78ce91f --- /dev/null +++ b/include/pgpl/render.h @@ -0,0 +1,8 @@ +#ifndef PGPL_RENDER_H +#define PGPL_RENDER_H + +#include +#include +#include + +#endif diff --git a/include/pgpl/render/color.h b/include/pgpl/render/color.h new file mode 100644 index 0000000..5f68029 --- /dev/null +++ b/include/pgpl/render/color.h @@ -0,0 +1,56 @@ +#ifndef PGPL_RENDER_COLOR_H +#define PGPL_RENDER_COLOR_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PGPL_Color type. This is simply a uint32_t. It contains an RGBA value: + * 0xFF000000 -> Red + * 0x00FF0000 -> Green + * 0x0000FF00 -> Blue + * 0x000000FF -> Alpha */ +typedef uint32_t PGPL_Color; + +/* Creates a new PGPL_Color with the given parameters. */ +static inline PGPL_Color pgpl_color_create(uint8_t red, uint8_t green, + uint8_t blue, uint8_t alpha) { + return ((uint32_t)red << 24) + ((uint32_t)green << 16) + + ((uint32_t)blue << 8) + (uint32_t)alpha; +} + +/* Gets the red value of the PGPL_Color type. */ +static inline uint8_t pgpl_color_get_red(PGPL_Color color) { + return (color >> 24) & 0xFF; +} + +/* Gets the green value of the PGPL_Color type. */ +static inline uint8_t pgpl_color_get_green(PGPL_Color color) { + return (color >> 16) & 0xFF; +} + +/* Gets the blue value of the PGPL_Color type. */ +static inline uint8_t pgpl_color_get_blue(PGPL_Color color) { + return (color >> 8) & 0xFF; +} + +/* Gets the alpha value of the PGPL_Color type. */ +static inline uint8_t pgpl_color_get_alpha(PGPL_Color color) { + return color & 0xFF; +} + +/* Divides all color values by the given amount. */ +static inline PGPL_Color pgpl_color_divide(PGPL_Color color, double divisor) { + return pgpl_color_create(pgpl_color_get_red(color) / divisor, + pgpl_color_get_green(color) / divisor, + pgpl_color_get_blue(color) / divisor, + pgpl_color_get_alpha(color)); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/render/font.h b/include/pgpl/render/font.h new file mode 100644 index 0000000..751ab11 --- /dev/null +++ b/include/pgpl/render/font.h @@ -0,0 +1,69 @@ +#ifndef PGPL_RENDER_FONT_H +#define PGPL_RENDER_FONT_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This creates a new font from a .ttf file. See pgpl_font_create for more + * info. */ +PGPL_Font *pgpl_font_create_from_file(const char *filename, + uint32_t glyph_size); + +/* This bakes a font from a .ttf file which is located somewhere in memory. The + * glyph_size parameter lets you modify the resolution of the baked glyphs. It + * can still be rendered at any size. Note that the data passed here will be + * freed automatically when the font gets destroyed, so do not attempt to free + * it yourself. */ +PGPL_Font *pgpl_font_create(uint8_t *data, uint32_t glyph_size); + +/* This frees all the resources associated with a font. It can also be with the + * renderer being NULL, this however does not delete the OpenGL texture that was + * created (it still gets deleted upon window destruction). Only use this if the + * window that the font was baked with no longer exists. */ +void pgpl_font_destroy(PGPL_Renderer *renderer, PGPL_Font *font); + +/* This renders a single glyph on the screen. The c parameter can hold any + * Unicode character value. The values in the xoff and yoff parameters will be + * offset to where the next character should be rendered. The color modulates + * the color of the font texture. */ +void pgpl_font_render_glyph(PGPL_Renderer *renderer, PGPL_Font *font, wchar_t c, + PGPL_Color color, double x, double y, double size, + double *xoff, double *yoff); + +/* This renders a whole UTF-8 string at a given position. Its parameters work + * similarily to pgpl_render_glyph. */ +void pgpl_font_render_string(PGPL_Renderer *renderer, PGPL_Font *font, + const char *str, PGPL_Color color, double x, + double y, double size); + +/* Works like pgpl_font_render_string, but takes a wchar_t string instead. */ +void pgpl_font_render_wstring(PGPL_Renderer *renderer, PGPL_Font *font, + wchar_t *str, PGPL_Color color, double x, + double y, double size); + +/* This calculates the dimensions of a glyph. in the top and left parameters it + * puts the coordinates of the top-left corner, and into the bottom and right + * coordinates those of the bottom-left corner respectively. */ +void pgpl_font_glyph_dimensions(PGPL_Font *font, wchar_t c, double size, + double *xoff, double *yoff, + PGPL_Rectangle *rectangle); + +/* Works similarily to pgpl_font_glyph_dimensions, however this calculates those + * values for an entire UTF-8 string. */ +void pgpl_font_string_dimensions(PGPL_Font *font, const char *str, double size, + PGPL_Rectangle *rectangle); + +/* Works like pgpl_font_string_dimensions, but takes a wchar_t string instead. + */ +void pgpl_font_wstring_dimensions(PGPL_Font *font, wchar_t *str, double size, + PGPL_Rectangle *rectangle); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/render/predef.h b/include/pgpl/render/predef.h new file mode 100644 index 0000000..310911d --- /dev/null +++ b/include/pgpl/render/predef.h @@ -0,0 +1,37 @@ +#ifndef PGPL_RENDER_PREDEF_H +#define PGPL_RENDER_PREDEF_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PGPL_Font type. Contains all the data needed to render glyphs on the window. + * None of its members should be accessed directly. */ +typedef struct PGPL_Font PGPL_Font; + +/* PGPL_Rectangle type. */ +typedef struct PGPL_Rectangle { + double top; + double left; + double bottom; + double right; +} PGPL_Rectangle; + +/* PGPL_Renderer type. Contains all necessary information for rendering. None of + * its members should be accessed directly. */ +typedef struct PGPL_Renderer { + uint32_t width, height; +} PGPL_Renderer; + +/* PGPL_Texture type. Contains a texture that can be rendered. None of its + * members should be accessed directly. */ +typedef struct PGPL_Texture PGPL_Texture; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/render/shapes.h b/include/pgpl/render/shapes.h new file mode 100644 index 0000000..92ae2e6 --- /dev/null +++ b/include/pgpl/render/shapes.h @@ -0,0 +1,39 @@ +#ifndef PGPL_RENDER_SHAPES_H +#define PGPL_RENDER_SHAPES_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Renders a basic rectangle with the given parameters. */ +void pgpl_render_rectangle(PGPL_Renderer *renderer, PGPL_Color color, double x, + double y, double width, double height); + +/* Renders a basic line with the given parameters. Note that this doesn't work + * that well if the scale is not at 1.0. */ +void pgpl_render_line(PGPL_Renderer *renderer, PGPL_Color color, double x0, + double y0, double x1, double y1); + +/* Renders a basic circle at the given coordinates with the given radius. The + * triangle count defines how many triangles should be rendered, the higher, the + * more accurate the circle will look. */ +void pgpl_render_circle(PGPL_Renderer *renderer, PGPL_Color color, double x, + double y, double radius, double triangle_amount); + +/* Renders a single dot at the given coordinates. Note that this doesn't work + * that well if the scale is not at 1.0. */ +void pgpl_render_point(PGPL_Renderer *renderer, PGPL_Color color, double x, + double y); + +/* Renders a basic triangle with the given parameters. */ +void pgpl_render_triangle(PGPL_Renderer *renderer, PGPL_Color color, double ax, + double ay, double bx, double by, double cx, + double cy); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/render/texture.h b/include/pgpl/render/texture.h new file mode 100644 index 0000000..0b2e44f --- /dev/null +++ b/include/pgpl/render/texture.h @@ -0,0 +1,73 @@ +#ifndef PGPL_RENDER_TEXTURE_H +#define PGPL_RENDER_TEXTURE_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This enum contains all possible texture filtering methods that textures can + * be created with. */ +typedef enum PGPL_TextureFilter { + PGPL_TEXTURE_FILTER_LINEAR, + PGPL_TEXTURE_FILTER_NEAREST +} PGPL_TextureFilter; + +/* This enum contains all possible texture formats that textures can be created + * from. */ +typedef enum PGPL_TextureFormat { + PGPL_TEXTURE_FORMAT_RGBA, + PGPL_TEXTURE_FORMAT_RGB, + PGPL_TEXTURE_FORMAT_BW +} PGPL_TextureFormat; + +/* This creates a texture from an image file stored in memory. The file_data is + * a pointer to it, and len is the lenght of the file_data. See + * pgpl_render_create_texture_file for more info. */ +PGPL_Texture *pgpl_render_create_texture_file_memory(PGPL_Renderer *renderer, + const uint8_t *file_data, + uint32_t len, + PGPL_TextureFilter filter); + +/* This creates a texture from a file. This supports anything that stb_image + * supports. You can also choose the filtering method to be used. */ +PGPL_Texture *pgpl_render_create_texture_file(PGPL_Renderer *renderer, + const char *filename, + PGPL_TextureFilter filter); + +/* This creates a texture from raw pixel data. The width and height are used to + * determine the size of the data. Note that RGB images are padded to 4 bytes + * per pixel. */ +PGPL_Texture *pgpl_render_create_texture(PGPL_Renderer *renderer, + const uint8_t *data, uint32_t width, + uint32_t height, + PGPL_TextureFilter filter, + PGPL_TextureFormat format); + +/* This frees any resources associated with a texture. Note that you can call + * this with renderer being NULL, this however doesn't get rid of any OpenGL + * data (it still gets deleted upon window destruction). Only call this with the + * renderer as NULL if the window it was created on is already destroyed. */ +void pgpl_render_destroy_texture(PGPL_Renderer *renderer, + PGPL_Texture *texture); + +/* This renders a texture at the given position and with the given size. Note + * that you can ONLY render images on the window they were created on. */ +void pgpl_render_texture(PGPL_Renderer *renderer, PGPL_Texture *texture, + double x, double y, double width, double height); + +/* This renders a texture with extended settings. The color parameter allows you + * to modulate the color of the texture, the s0, s1, t0 and t1 parameters let + * you specify coordinates on a given texture, so that you only render a part of + * the texture. See pgpl_render_texture for more info. */ +void pgpl_render_texture_extended(PGPL_Renderer *renderer, + PGPL_Texture *texture, double x, double y, + double width, double height, PGPL_Color color, + double s0, double t0, double s1, double t1); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/thread.h b/include/pgpl/thread.h new file mode 100644 index 0000000..8d5fb6e --- /dev/null +++ b/include/pgpl/thread.h @@ -0,0 +1,46 @@ +#ifndef PGPL_THREAD_H +#define PGPL_THREAD_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* These are the thread and mutex abstraction structs, do not try to modify + * their contents. */ +typedef struct PGPL_Thread PGPL_Thread; +typedef struct PGPL_Mutex PGPL_Mutex; + +/* This creates a new thread, which executes the given function with the given + * argument. */ +PGPL_Thread *pgpl_thread_create(void *(*function)(void *arg), void *arg); + +/* This destroys a thread. This doesn't actually stop the execution of the + * thread however, it simply just frees the data. */ +void pgpl_thread_destroy(PGPL_Thread *thread); + +/* This blocks until the thread finishes executing. */ +void pgpl_thread_join(PGPL_Thread *thread); + +/* This creates a new mutex. */ +PGPL_Mutex *pgpl_mutex_create(void); + +/* This destroys a mutex. */ +void pgpl_mutex_destroy(PGPL_Mutex *mutex); + +/* This locks a mutex, and blocks until said mutex can be locked. */ +void pgpl_mutex_lock(PGPL_Mutex *mutex); + +/* This attempts to lock a mutex. If it fails, this will return false, else it + * will return true. */ +bool pgpl_mutex_try_lock(PGPL_Mutex *mutex); + +/* This will unlock a mutex. */ +void pgpl_mutex_unlock(PGPL_Mutex *mutex); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/timer.h b/include/pgpl/timer.h new file mode 100644 index 0000000..a91ecd6 --- /dev/null +++ b/include/pgpl/timer.h @@ -0,0 +1,33 @@ +#ifndef PGPL_TIMER_H +#define PGPL_TIMER_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PGPL_Timer was never designed with accuracy in mind. It just serves as an + * easy way to prevent busy wait loops in a cross-platform manner. */ + +/* The PGPL_Timer type contains all info needed by the pgpl_timer functions. */ +typedef struct PGPL_Timer PGPL_Timer; + +/* This creates a new PGPL_Timer. */ +PGPL_Timer *pgpl_timer_create(void); + +/* This gets the time in milliseconds since the last time it was measured. */ +uint32_t pgpl_timer_get_delta(PGPL_Timer *timer); + +/* This destroys a PGPL_Timer */ +void pgpl_timer_destroy(PGPL_Timer *timer); + +/* This sleeps for the given amount of milliseconds. This function is not + * guaranteed to be 100% accurate. */ +void pgpl_timer_sleep(uint32_t milliseconds); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/vector.h b/include/pgpl/vector.h new file mode 100644 index 0000000..d948666 --- /dev/null +++ b/include/pgpl/vector.h @@ -0,0 +1,68 @@ +#ifndef PGPL_VECTOR_H +#define PGPL_VECTOR_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PGPL_Vector is NOT thread safe. It can be used from multiple threads, but the + * synchronization is up to the user. */ + +/* Contents of the PGPL_Vector struct should not be accessed directly. */ +typedef struct PGPL_Vector PGPL_Vector; + +/* Creates a new Vector which can then store data with the given data_size. */ +PGPL_Vector *pgpl_vector_create(uint32_t data_size); + +/* This destroys a vector created by pgpl_vector_create. */ +void pgpl_vector_destroy(PGPL_Vector *vector); + +/* Pushes data of the vectors data_size onto the back of the vector. */ +void pgpl_vector_push_back(PGPL_Vector *vector, void *data); + +/* Pushes data of the vectors data_size onto the front of the vector. This is + * slower than pushing it onto the back. */ +void pgpl_vector_push_front(PGPL_Vector *vector, void *data); + +/* Pops data of the vectors data_size from the back of the vector. Do not free + * the returned pointer. The memory becomes invalid after running another pop or + * delete on the array. */ +void *pgpl_vector_pop_back(PGPL_Vector *vector); + +/* Pops data of the vectors data_size from the back of the vector. Do not free + * the returned pointer. Slower than poping from the back. The memory becomes + * invalid after running another pop or delete on the array. */ +void *pgpl_vector_pop_front(PGPL_Vector *vector); + +/* Returns the top entry on the back of the vector. The returned pointer points + * to data inside of the vector, and may be used to modify the entry's content. + * Do not free the returned pointer */ +void *pgpl_vector_peek_back(PGPL_Vector *vector); + +/* Returns the top entry on the front of the vector. The returned pointer points + * to data inside of the vector, and may be used to modify the entry's content. + * Do not free the returned pointer */ +void *pgpl_vector_peek_front(PGPL_Vector *vector); + +/* Deletes an index from the vector. The returned pointer should not be freed. + * The memory is invalid after running another pop or delete on the array. */ +void *pgpl_vector_delete_index(PGPL_Vector *vector, uint32_t index); + +/* Inserts data of the vectors data_size after the given index. */ +void pgpl_vector_insert_after_index(PGPL_Vector *vector, uint32_t index, + void *data); + +/* Returns a pointer to the data at the given index. You may modify the contents + * of this memory, and this will reflect in the vector itself. */ +void *pgpl_vector_get_index(PGPL_Vector *vector, uint32_t index); + +/* Returns the length of the vector. */ +uint32_t pgpl_vector_get_length(PGPL_Vector *vector); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/window.h b/include/pgpl/window.h new file mode 100644 index 0000000..b2a1af2 --- /dev/null +++ b/include/pgpl/window.h @@ -0,0 +1,114 @@ +#ifndef PGPL_WINDOW_H +#define PGPL_WINDOW_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Mouse button event enum. Goes from 1-5. */ +typedef enum PGPL_WindowMouseButton { + PGPL_WINDOW_MOUSE_BUTTON_LEFT = 1, + PGPL_WINDOW_MOUSE_BUTTON_MIDDLE, + PGPL_WINDOW_MOUSE_BUTTON_RIGHT, + PGPL_WINDOW_MOUSE_BUTTON_SCROLL_UP, + PGPL_WINDOW_MOUSE_BUTTON_SCROLL_DOWN +} PGPL_WindowMouseButton; + +/* Creates a new Window with the given parameters. Do not call free on the + * returned object manually. */ +PGPL_Window *pgpl_window_create(const char *title, uint32_t width, + uint32_t height, int32_t x, int32_t y); + +/* Destroys the window and frees all its resources. Does not free rendering + * objects. */ +void pgpl_window_destroy(PGPL_Window *window); + +/* Makes the window visible. */ +void pgpl_window_show(PGPL_Window *window); + +/* Makes the window invisible. */ +void pgpl_window_hide(PGPL_Window *window); + +/* Sets a new title for the window. */ +void pgpl_window_set_title(PGPL_Window *window, const char *title); + +/* Returns the current title of the window. Note that the returned pointer is + * only valid during the windows existance. Changing the title may also change + * what the returned string points to. Do not call free on the + * returned object manually. */ +const char *pgpl_window_get_title(PGPL_Window *window); + +/* Returns the windows size in the passed pointers. The width and height + * pointers are allowed to be NULL. */ +void pgpl_window_get_size(PGPL_Window *window, uint32_t *width, + uint32_t *height); + +/* Changes the windows size to the passed width and height */ +void pgpl_window_set_size(PGPL_Window *window, uint32_t width, uint32_t height); + +/* Returns the windows position in the passed pointers. The x and y pointers are + * allowed to be NULL. */ +void pgpl_window_get_position(PGPL_Window *window, int32_t *x, int32_t *y); + +/* Changes the windows position to the passed x and y */ +void pgpl_window_set_position(PGPL_Window *window, int32_t x, int32_t y); + +/* Sets the rendering scale of the window. */ +void pgpl_window_set_scale(PGPL_Window *window, double scale); + +/* Gets the rendering scale of the window. */ +double pgpl_window_get_scale(PGPL_Window *window); + +/* This makes the window always display above the parent window. On Windows this + * reparents the window without removing it's borders, so that it still looks + * like a window. On X11 this works just like the respective X11 function. The + * parent pointer must either be of type HWND (on Windows) or of type Window * + * (on X11). */ +void pgpl_window_set_transient(PGPL_Window *window, void *parent); + +/* This reparents the window to the parent window. On Windows this also removes + * the childs windows borders. The parent pointer must either be of type HWND + * (on Windows) or of type Window * (on X11). */ +void pgpl_window_reparent_to(PGPL_Window *window, void *parent); + +/* This gets you the raw Window handle. This will be of type HWND (on Windows) + * or of type Window * (on X11). */ +void *pgpl_window_get_raw_window(PGPL_Window *window); + +/* This fetches all events from the window into an internal queue, and returns + * back data of the first event found. */ +PGPL_WindowEventType pgpl_window_fetch_event(PGPL_Window *window, + PGPL_WindowEventData *event_data); + +/* This creates a new window event and puts it into the internal queue. */ +void pgpl_window_create_event(PGPL_Window *window, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data); + +/* This starts a render on a window, and clears it with the given color. Within + * any given program, you can only have one renderer at a time because of + * OpenGL. Any new calls to this function will block until the rendering is + * stopped. + * + * It is recommended to only call this at the beginning of a render event + * on a window, and then finish it at the end of a render event. It is however + * allowed to start a render at any time. + * + * If you need to clean up any rendering resources upon program exit, you are + * allowed to do so without starting a new render. All OpenGL objects are freed + * upon window destruction. */ +PGPL_Renderer *pgpl_window_start_render(PGPL_Window *window, PGPL_Color color); + +/* This finishes a render, and displays the rendered buffer on the window. See + * the pgpl_window_start_render function for more information. */ +void pgpl_window_finish_render(PGPL_Window *window, PGPL_Renderer *renderer); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/window/predef.h b/include/pgpl/window/predef.h new file mode 100644 index 0000000..2a61482 --- /dev/null +++ b/include/pgpl/window/predef.h @@ -0,0 +1,50 @@ +#ifndef PGPL_WINDOW_PREDEF_H +#define PGPL_WINDOW_PREDEF_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* PGPL_WindowThread type. Contains all the data that is needed by the thread + * loop and a PGPL_Window. None of its members should be accessed directly. */ +typedef struct PGPL_WindowThread PGPL_WindowThread; + +/* PGPL_Window type. This contains all of the data associated with a window. + * None of its members should be accessed directly. */ +typedef struct PGPL_Window PGPL_Window; + +/* This is an input event which is returned on PGPL_WINDOW_EVENT_KEY_* and + * PGPL_WINDOW_EVENT_MOUSE_* events. */ +typedef struct PGPL_WindowInputEvent { + uint32_t key; + int32_t x; + int32_t y; +} PGPL_WindowInputEvent; + +/* This is the event data type, it allows you to access extended information for + * certain window events. */ +typedef union PGPL_WindowEventData { + PGPL_WindowInputEvent input_event; +} PGPL_WindowEventData; + +/* This is an enum containing all kinds of window events. Further details can be + * read from the PGPL_WindowEventData type. */ +typedef enum PGPL_WindowEventType { + PGPL_WINDOW_EVENT_NONE, + PGPL_WINDOW_EVENT_RENDER_REQUEST, + PGPL_WINDOW_EVENT_KEY_PRESS, + PGPL_WINDOW_EVENT_KEY_RELEASE, + PGPL_WINDOW_EVENT_MOUSE_PRESS, + PGPL_WINDOW_EVENT_MOUSE_RELEASE, + PGPL_WINDOW_EVENT_MOUSE_MOVE, + PGPL_WINDOW_EVENT_CLOSE, + PGPL_WINDOW_EVENT_ERROR +} PGPL_WindowEventType; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/pgpl/window/thread.h b/include/pgpl/window/thread.h new file mode 100644 index 0000000..592d158 --- /dev/null +++ b/include/pgpl/window/thread.h @@ -0,0 +1,104 @@ +#ifndef PGPL_WINDOW_THREAD_H +#define PGPL_WINDOW_THREAD_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* This creates a new thread loop, in which a window is also created. The first + * five parameters are shared with the non threaded counterpart. The event_loop + * function is called whenever there is a window event. The user_data parameter + * can be any custom pointer to anything that might be needed inside of the + * event_loop. If the user_data is not needed it can also be NULL. + * + * Returning false from the event_loop will close the window. + */ +PGPL_WindowThread *pgpl_window_thread_create( + const char *title, uint32_t width, uint32_t height, int32_t x, int32_t y, + bool (*event_loop)(PGPL_Window *window, PGPL_WindowEventType event, + PGPL_WindowEventData *event_data, void *user_data), + void *user_data); + +/* This exits the thread loop that is running in the background. It also frees + * all resources that were created for this thread, including the Window that + * was created in the thread. */ +void pgpl_window_thread_destroy(PGPL_WindowThread *window_thread); + +/* Threaded version of pgpl_window_show, see pgpl_window_show for more + * information. */ +void pgpl_window_thread_show(PGPL_WindowThread *window_thread); + +/* Threaded version of pgpl_window_hide, see pgpl_window_hide for more + * information. */ +void pgpl_window_thread_hide(PGPL_WindowThread *window_thread); + +/* Threaded version of pgpl_window_set_title, see pgpl_window_set_title for more + * information. */ +void pgpl_window_thread_set_title(PGPL_WindowThread *window_thread, + const char *title); + +/* Threaded version of pgpl_window_get_title, see pgpl_window_get_title for more + * information. */ +const char *pgpl_window_thread_get_title(PGPL_WindowThread *window_thread); + +/* Threaded version of pgpl_window_get_size, see pgpl_window_get_size for more + * information. */ +void pgpl_window_thread_get_size(PGPL_WindowThread *window_thread, + uint32_t *width, uint32_t *height); + +/* Threaded version of pgpl_window_set_size, see pgpl_window_set_size for more + * information. */ +void pgpl_window_thread_set_size(PGPL_WindowThread *window_thread, + uint32_t width, uint32_t height); + +/* Threaded version of pgpl_window_get_position, see pgpl_window_get_position + * for more information. */ +void pgpl_window_thread_get_position(PGPL_WindowThread *window_thread, + int32_t *x, int32_t *y); + +/* Threaded version of pgpl_window_set_position, see pgpl_window_set_position + * for more information. */ +void pgpl_window_thread_set_position(PGPL_WindowThread *window_thread, + int32_t x, int32_t y); + +/* Threaded version of pgpl_window_get_scale, see pgpl_window_get_scale for more + * information. */ +double pgpl_window_thread_get_scale(PGPL_WindowThread *window_thread); + +/* Threaded version of pgpl_window_set_scale, see pgpl_window_set_scale for more + * information. */ +void pgpl_window_thread_set_scale(PGPL_WindowThread *window_thread, + double scale); + +/* Threaded version of pgpl_window_create_event, see pgpl_window_create_event + * for more information. */ +void pgpl_window_thread_create_event(PGPL_WindowThread *window_thread, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data); + +/* Threaded version of pgpl_window_set_transient, see pgpl_window_set_transient + * for more information. */ +void pgpl_window_thread_set_transient(PGPL_WindowThread *window_thread, + void *parent); + +/* Threaded version of pgpl_window_reparent_to, see pgpl_window_reparent_to for + * more information. */ +void pgpl_window_thread_reparent_to(PGPL_WindowThread *window_thread, + void *parent); + +/* Threaded version of pgpl_window_get_raw_window, see + * pgpl_window_get_raw_window for more information. */ +void *pgpl_window_thread_get_raw_window(PGPL_WindowThread *window_thread); + +/* This function halts until the window_thread is destroyed. This function only + * works once per window_thread. */ +void pgpl_window_thread_await_destruction(PGPL_WindowThread *window_thread); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/stb/stb_image.h b/include/stb/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/include/stb/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/include/stb/stb_truetype.h b/include/stb/stb_truetype.h new file mode 100644 index 0000000..90a5c2e --- /dev/null +++ b/include/stb/stb_truetype.h @@ -0,0 +1,5079 @@ +// stb_truetype.h - v1.26 - public domain +// authored from 2009-2021 by Sean Barrett / RAD Game Tools +// +// ======================================================================= +// +// NO SECURITY GUARANTEE -- DO NOT USE THIS ON UNTRUSTED FONT FILES +// +// This library does no range checking of the offsets found in the file, +// meaning an attacker can use it to read arbitrary memory. +// +// ======================================================================= +// +// This library processes TrueType files: +// parse files +// extract glyph metrics +// extract glyph shapes +// render glyphs to one-channel bitmaps with antialiasing (box filter) +// render glyphs to one-channel SDF bitmaps (signed-distance field/function) +// +// Todo: +// non-MS cmaps +// crashproof on bad data +// hinting? (no longer patented) +// cleartype-style AA? +// optimize: use simple memory allocator for intermediates +// optimize: build edge-list directly from curves +// optimize: rasterize directly from curves? +// +// ADDITIONAL CONTRIBUTORS +// +// Mikko Mononen: compound shape support, more cmap formats +// Tor Andersson: kerning, subpixel rendering +// Dougall Johnson: OpenType / Type 2 font handling +// Daniel Ribeiro Maciel: basic GPOS-based kerning +// +// Misc other: +// Ryan Gordon +// Simon Glass +// github:IntellectualKitty +// Imanol Celaya +// Daniel Ribeiro Maciel +// +// Bug/warning reports/fixes: +// "Zer" on mollyrocket Fabian "ryg" Giesen github:NiLuJe +// Cass Everitt Martins Mozeiko github:aloucks +// stoiko (Haemimont Games) Cap Petschulat github:oyvindjam +// Brian Hook Omar Cornut github:vassvik +// Walter van Niftrik Ryan Griege +// David Gow Peter LaValle +// David Given Sergey Popov +// Ivan-Assen Ivanov Giumo X. Clanjor +// Anthony Pesch Higor Euripedes +// Johan Duparc Thomas Fields +// Hou Qiming Derek Vinyard +// Rob Loach Cort Stratton +// Kenney Phillis Jr. Brian Costabile +// Ken Voskuil (kaesve) Yakov Galka +// +// VERSION HISTORY +// +// 1.26 (2021-08-28) fix broken rasterizer +// 1.25 (2021-07-11) many fixes +// 1.24 (2020-02-05) fix warning +// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) +// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined +// 1.21 (2019-02-25) fix warning +// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() +// 1.19 (2018-02-11) GPOS kerning, STBTT_fmod +// 1.18 (2018-01-29) add missing function +// 1.17 (2017-07-23) make more arguments const; doc fix +// 1.16 (2017-07-12) SDF support +// 1.15 (2017-03-03) make more arguments const +// 1.14 (2017-01-16) num-fonts-in-TTC function +// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts +// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual +// 1.11 (2016-04-02) fix unused-variable warning +// 1.10 (2016-04-02) user-defined fabs(); rare memory leak; remove duplicate typedef +// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use allocation userdata properly +// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges +// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; +// variant PackFontRanges to pack and render in separate phases; +// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); +// fixed an assert() bug in the new rasterizer +// replace assert() with STBTT_assert() in new rasterizer +// +// Full history can be found at the end of this file. +// +// LICENSE +// +// See end of file for license information. +// +// USAGE +// +// Include this file in whatever places need to refer to it. In ONE C/C++ +// file, write: +// #define STB_TRUETYPE_IMPLEMENTATION +// before the #include of this file. This expands out the actual +// implementation into that C/C++ file. +// +// To make the implementation private to the file that generates the implementation, +// #define STBTT_STATIC +// +// Simple 3D API (don't ship this, but it's fine for tools and quick start) +// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture +// stbtt_GetBakedQuad() -- compute quad to draw for a given char +// +// Improved 3D API (more shippable): +// #include "stb_rect_pack.h" -- optional, but you really want it +// stbtt_PackBegin() +// stbtt_PackSetOversampling() -- for improved quality on small fonts +// stbtt_PackFontRanges() -- pack and renders +// stbtt_PackEnd() +// stbtt_GetPackedQuad() +// +// "Load" a font file from a memory buffer (you have to keep the buffer loaded) +// stbtt_InitFont() +// stbtt_GetFontOffsetForIndex() -- indexing for TTC font collections +// stbtt_GetNumberOfFonts() -- number of fonts for TTC font collections +// +// Render a unicode codepoint to a bitmap +// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap +// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide +// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be +// +// Character advance/positioning +// stbtt_GetCodepointHMetrics() +// stbtt_GetFontVMetrics() +// stbtt_GetFontVMetricsOS2() +// stbtt_GetCodepointKernAdvance() +// +// Starting with version 1.06, the rasterizer was replaced with a new, +// faster and generally-more-precise rasterizer. The new rasterizer more +// accurately measures pixel coverage for anti-aliasing, except in the case +// where multiple shapes overlap, in which case it overestimates the AA pixel +// coverage. Thus, anti-aliasing of intersecting shapes may look wrong. If +// this turns out to be a problem, you can re-enable the old rasterizer with +// #define STBTT_RASTERIZER_VERSION 1 +// which will incur about a 15% speed hit. +// +// ADDITIONAL DOCUMENTATION +// +// Immediately after this block comment are a series of sample programs. +// +// After the sample programs is the "header file" section. This section +// includes documentation for each API function. +// +// Some important concepts to understand to use this library: +// +// Codepoint +// Characters are defined by unicode codepoints, e.g. 65 is +// uppercase A, 231 is lowercase c with a cedilla, 0x7e30 is +// the hiragana for "ma". +// +// Glyph +// A visual character shape (every codepoint is rendered as +// some glyph) +// +// Glyph index +// A font-specific integer ID representing a glyph +// +// Baseline +// Glyph shapes are defined relative to a baseline, which is the +// bottom of uppercase characters. Characters extend both above +// and below the baseline. +// +// Current Point +// As you draw text to the screen, you keep track of a "current point" +// which is the origin of each character. The current point's vertical +// position is the baseline. Even "baked fonts" use this model. +// +// Vertical Font Metrics +// The vertical qualities of the font, used to vertically position +// and space the characters. See docs for stbtt_GetFontVMetrics. +// +// Font Size in Pixels or Points +// The preferred interface for specifying font sizes in stb_truetype +// is to specify how tall the font's vertical extent should be in pixels. +// If that sounds good enough, skip the next paragraph. +// +// Most font APIs instead use "points", which are a common typographic +// measurement for describing font size, defined as 72 points per inch. +// stb_truetype provides a point API for compatibility. However, true +// "per inch" conventions don't make much sense on computer displays +// since different monitors have different number of pixels per +// inch. For example, Windows traditionally uses a convention that +// there are 96 pixels per inch, thus making 'inch' measurements have +// nothing to do with inches, and thus effectively defining a point to +// be 1.333 pixels. Additionally, the TrueType font data provides +// an explicit scale factor to scale a given font's glyphs to points, +// but the author has observed that this scale factor is often wrong +// for non-commercial fonts, thus making fonts scaled in points +// according to the TrueType spec incoherently sized in practice. +// +// DETAILED USAGE: +// +// Scale: +// Select how high you want the font to be, in points or pixels. +// Call ScaleForPixelHeight or ScaleForMappingEmToPixels to compute +// a scale factor SF that will be used by all other functions. +// +// Baseline: +// You need to select a y-coordinate that is the baseline of where +// your text will appear. Call GetFontBoundingBox to get the baseline-relative +// bounding box for all characters. SF*-y0 will be the distance in pixels +// that the worst-case character could extend above the baseline, so if +// you want the top edge of characters to appear at the top of the +// screen where y=0, then you would set the baseline to SF*-y0. +// +// Current point: +// Set the current point where the first character will appear. The +// first character could extend left of the current point; this is font +// dependent. You can either choose a current point that is the leftmost +// point and hope, or add some padding, or check the bounding box or +// left-side-bearing of the first character to be displayed and set +// the current point based on that. +// +// Displaying a character: +// Compute the bounding box of the character. It will contain signed values +// relative to . I.e. if it returns x0,y0,x1,y1, +// then the character should be displayed in the rectangle from +// to = 32 && *text < 128) { + stbtt_aligned_quad q; + stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl & d3d10+,0=d3d9 + glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y0); + glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y0); + glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y1); + glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y1); + } + ++text; + } + glEnd(); +} +#endif +// +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program (this compiles): get a single bitmap, print as ASCII art +// +#if 0 +#include +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation +#include "stb_truetype.h" + +char ttf_buffer[1<<25]; + +int main(int argc, char **argv) +{ + stbtt_fontinfo font; + unsigned char *bitmap; + int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); + + fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); + + stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); + bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); + + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) + putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); + putchar('\n'); + } + return 0; +} +#endif +// +// Output: +// +// .ii. +// @@@@@@. +// V@Mio@@o +// :i. V@V +// :oM@@M +// :@@@MM@M +// @@o o@M +// :@@. M@M +// @@@o@@@@ +// :M@@V:@@. +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program: print "Hello World!" banner, with bugs +// +#if 0 +char buffer[24<<20]; +unsigned char screen[20][79]; + +int main(int arg, char **argv) +{ + stbtt_fontinfo font; + int i,j,ascent,baseline,ch=0; + float scale, xpos=2; // leave a little padding in case the character extends left + char *text = "Heljo World!"; // intentionally misspelled to show 'lj' brokenness + + fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); + stbtt_InitFont(&font, buffer, 0); + + scale = stbtt_ScaleForPixelHeight(&font, 15); + stbtt_GetFontVMetrics(&font, &ascent,0,0); + baseline = (int) (ascent*scale); + + while (text[ch]) { + int advance,lsb,x0,y0,x1,y1; + float x_shift = xpos - (float) floor(xpos); + stbtt_GetCodepointHMetrics(&font, text[ch], &advance, &lsb); + stbtt_GetCodepointBitmapBoxSubpixel(&font, text[ch], scale,scale,x_shift,0, &x0,&y0,&x1,&y1); + stbtt_MakeCodepointBitmapSubpixel(&font, &screen[baseline + y0][(int) xpos + x0], x1-x0,y1-y0, 79, scale,scale,x_shift,0, text[ch]); + // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong + // because this API is really for baking character bitmaps into textures. if you want to render + // a sequence of characters, you really need to render each bitmap to a temp buffer, then + // "alpha blend" that into the working buffer + xpos += (advance * scale); + if (text[ch+1]) + xpos += scale*stbtt_GetCodepointKernAdvance(&font, text[ch],text[ch+1]); + ++ch; + } + + for (j=0; j < 20; ++j) { + for (i=0; i < 78; ++i) + putchar(" .:ioVM@"[screen[j][i]>>5]); + putchar('\n'); + } + + return 0; +} +#endif + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// INTEGRATION WITH YOUR CODEBASE +//// +//// The following sections allow you to supply alternate definitions +//// of C library functions used by stb_truetype, e.g. if you don't +//// link with the C runtime library. + +#ifdef STB_TRUETYPE_IMPLEMENTATION + // #define your own (u)stbtt_int8/16/32 before including to override this + #ifndef stbtt_uint8 + typedef unsigned char stbtt_uint8; + typedef signed char stbtt_int8; + typedef unsigned short stbtt_uint16; + typedef signed short stbtt_int16; + typedef unsigned int stbtt_uint32; + typedef signed int stbtt_int32; + #endif + + typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; + typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; + + // e.g. #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h + #ifndef STBTT_ifloor + #include + #define STBTT_ifloor(x) ((int) floor(x)) + #define STBTT_iceil(x) ((int) ceil(x)) + #endif + + #ifndef STBTT_sqrt + #include + #define STBTT_sqrt(x) sqrt(x) + #define STBTT_pow(x,y) pow(x,y) + #endif + + #ifndef STBTT_fmod + #include + #define STBTT_fmod(x,y) fmod(x,y) + #endif + + #ifndef STBTT_cos + #include + #define STBTT_cos(x) cos(x) + #define STBTT_acos(x) acos(x) + #endif + + #ifndef STBTT_fabs + #include + #define STBTT_fabs(x) fabs(x) + #endif + + // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h + #ifndef STBTT_malloc + #include + #define STBTT_malloc(x,u) ((void)(u),malloc(x)) + #define STBTT_free(x,u) ((void)(u),free(x)) + #endif + + #ifndef STBTT_assert + #include + #define STBTT_assert(x) assert(x) + #endif + + #ifndef STBTT_strlen + #include + #define STBTT_strlen(x) strlen(x) + #endif + + #ifndef STBTT_memcpy + #include + #define STBTT_memcpy memcpy + #define STBTT_memset memset + #endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// INTERFACE +//// +//// + +#ifndef __STB_INCLUDE_STB_TRUETYPE_H__ +#define __STB_INCLUDE_STB_TRUETYPE_H__ + +#ifdef STBTT_STATIC +#define STBTT_DEF static +#else +#define STBTT_DEF extern +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// private structure +typedef struct +{ + unsigned char *data; + int cursor; + int size; +} stbtt__buf; + +////////////////////////////////////////////////////////////////////////////// +// +// TEXTURE BAKING API +// +// If you use this API, you only have to call two functions ever. +// + +typedef struct +{ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap + float xoff,yoff,xadvance; +} stbtt_bakedchar; + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata); // you allocate this, it's num_chars long +// if return is positive, the first unused row of the bitmap +// if return is negative, returns the negative of the number of characters that fit +// if return is 0, no characters fit and no rows were used +// This uses a very crappy packing. + +typedef struct +{ + float x0,y0,s0,t0; // top-left + float x1,y1,s1,t1; // bottom-right +} stbtt_aligned_quad; + +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier +// Call GetBakedQuad with char_index = 'character - first_char', and it +// creates the quad you need to draw and advances the current position. +// +// The coordinate system used assumes y increases downwards. +// +// Characters will extend both above and below the current position; +// see discussion of "BASELINE" above. +// +// It's inefficient; you might want to c&p it and optimize it. + +STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap); +// Query the font vertical metrics without having to create a font first. + + +////////////////////////////////////////////////////////////////////////////// +// +// NEW TEXTURE BAKING API +// +// This provides options for packing multiple fonts into one atlas, not +// perfectly but better than nothing. + +typedef struct +{ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap + float xoff,yoff,xadvance; + float xoff2,yoff2; +} stbtt_packedchar; + +typedef struct stbtt_pack_context stbtt_pack_context; +typedef struct stbtt_fontinfo stbtt_fontinfo; +#ifndef STB_RECT_PACK_VERSION +typedef struct stbrp_rect stbrp_rect; +#endif + +STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int width, int height, int stride_in_bytes, int padding, void *alloc_context); +// Initializes a packing context stored in the passed-in stbtt_pack_context. +// Future calls using this context will pack characters into the bitmap passed +// in here: a 1-channel bitmap that is width * height. stride_in_bytes is +// the distance from one row to the next (or 0 to mean they are packed tightly +// together). "padding" is the amount of padding to leave between each +// character (normally you want '1' for bitmaps you'll use as textures with +// bilinear filtering). +// +// Returns 0 on failure, 1 on success. + +STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc); +// Cleans up the packing context and frees all memory. + +#define STBTT_POINT_SIZE(x) (-(x)) + +STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, + int first_unicode_char_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range); +// Creates character bitmaps from the font_index'th font found in fontdata (use +// font_index=0 if you don't know what that is). It creates num_chars_in_range +// bitmaps for characters with unicode values starting at first_unicode_char_in_range +// and increasing. Data for how to render them is stored in chardata_for_range; +// pass these to stbtt_GetPackedQuad to get back renderable quads. +// +// font_size is the full height of the character from ascender to descender, +// as computed by stbtt_ScaleForPixelHeight. To use a point size as computed +// by stbtt_ScaleForMappingEmToPixels, wrap the point size in STBTT_POINT_SIZE() +// and pass that result as 'font_size': +// ..., 20 , ... // font max minus min y is 20 pixels tall +// ..., STBTT_POINT_SIZE(20), ... // 'M' is 20 pixels tall + +typedef struct +{ + float font_size; + int first_unicode_codepoint_in_range; // if non-zero, then the chars are continuous, and this is the first codepoint + int *array_of_unicode_codepoints; // if non-zero, then this is an array of unicode codepoints + int num_chars; + stbtt_packedchar *chardata_for_range; // output + unsigned char h_oversample, v_oversample; // don't set these, they're used internally +} stbtt_pack_range; + +STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges); +// Creates character bitmaps from multiple ranges of characters stored in +// ranges. This will usually create a better-packed bitmap than multiple +// calls to stbtt_PackFontRange. Note that you can call this multiple +// times within a single PackBegin/PackEnd. + +STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample); +// Oversampling a font increases the quality by allowing higher-quality subpixel +// positioning, and is especially valuable at smaller text sizes. +// +// This function sets the amount of oversampling for all following calls to +// stbtt_PackFontRange(s) or stbtt_PackFontRangesGatherRects for a given +// pack context. The default (no oversampling) is achieved by h_oversample=1 +// and v_oversample=1. The total number of pixels required is +// h_oversample*v_oversample larger than the default; for example, 2x2 +// oversampling requires 4x the storage of 1x1. For best results, render +// oversampled textures with bilinear filtering. Look at the readme in +// stb/tests/oversample for information about oversampled fonts +// +// To use with PackFontRangesGather etc., you must set it before calls +// call to PackFontRangesGatherRects. + +STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip); +// If skip != 0, this tells stb_truetype to skip any codepoints for which +// there is no corresponding glyph. If skip=0, which is the default, then +// codepoints without a glyph recived the font's "missing character" glyph, +// typically an empty box by convention. + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int align_to_integer); + +STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); +STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects); +STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects); +// Calling these functions in sequence is roughly equivalent to calling +// stbtt_PackFontRanges(). If you more control over the packing of multiple +// fonts, or if you want to pack custom data into a font texture, take a look +// at the source to of stbtt_PackFontRanges() and create a custom version +// using these functions, e.g. call GatherRects multiple times, +// building up a single array of rects, then call PackRects once, +// then call RenderIntoRects repeatedly. This may result in a +// better packing than calling PackFontRanges multiple times +// (or it may not). + +// this is an opaque structure that you shouldn't mess with which holds +// all the context needed from PackBegin to PackEnd. +struct stbtt_pack_context { + void *user_allocator_context; + void *pack_info; + int width; + int height; + int stride_in_bytes; + int padding; + int skip_missing; + unsigned int h_oversample, v_oversample; + unsigned char *pixels; + void *nodes; +}; + +////////////////////////////////////////////////////////////////////////////// +// +// FONT LOADING +// +// + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data); +// This function will determine the number of fonts in a font file. TrueType +// collection (.ttc) files may contain multiple fonts, while TrueType font +// (.ttf) files only contain one font. The number of fonts can be used for +// indexing with the previous function where the index is between zero and one +// less than the total fonts. If an error occurs, -1 is returned. + +STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); +// Each .ttf/.ttc file may have more than one font. Each font has a sequential +// index number starting from 0. Call this function to get the font offset for +// a given index; it returns -1 if the index is out of range. A regular .ttf +// file will only define one font and it always be at offset 0, so it will +// return '0' for index 0, and -1 for all other indices. + +// The following structure is defined publicly so you can declare one on +// the stack or as a global or etc, but you should treat it as opaque. +struct stbtt_fontinfo +{ + void * userdata; + unsigned char * data; // pointer to .ttf file + int fontstart; // offset of start of font + + int numGlyphs; // number of glyphs, needed for range checking + + int loca,head,glyf,hhea,hmtx,kern,gpos,svg; // table locations as offset from start of .ttf + int index_map; // a cmap mapping for our chosen character encoding + int indexToLocFormat; // format needed to map from glyph index to glyph + + stbtt__buf cff; // cff font data + stbtt__buf charstrings; // the charstring index + stbtt__buf gsubrs; // global charstring subroutines index + stbtt__buf subrs; // private charstring subroutines index + stbtt__buf fontdicts; // array of font dicts + stbtt__buf fdselect; // map from glyph to fontdict +}; + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); +// Given an offset into the file that defines a font, this function builds +// the necessary cached info for the rest of the system. You must allocate +// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't +// need to do anything special to free it, because the contents are pure +// value data with no additional data structures. Returns 0 on failure. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER TO GLYPH-INDEX CONVERSIOn + +STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); +// If you're going to perform multiple operations on the same character +// and you want a speed-up, call this function with the character you're +// going to process, then use glyph-based functions instead of the +// codepoint-based functions. +// Returns 0 if the character codepoint is not defined in the font. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER PROPERTIES +// + +STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); +// computes a scale factor to produce a font whose "height" is 'pixels' tall. +// Height is measured as the distance from the highest ascender to the lowest +// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics +// and computing: +// scale = pixels / (ascent - descent) +// so if you prefer to measure height by the ascent only, use a similar calculation. + +STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels); +// computes a scale factor to produce a font whose EM size is mapped to +// 'pixels' tall. This is probably what traditional APIs compute, but +// I'm not positive. + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); +// ascent is the coordinate above the baseline the font extends; descent +// is the coordinate below the baseline the font extends (i.e. it is typically negative) +// lineGap is the spacing between one row's descent and the next row's ascent... +// so you should advance the vertical position by "*ascent - *descent + *lineGap" +// these are expressed in unscaled coordinates, so you must multiply by +// the scale factor for a given size + +STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap); +// analogous to GetFontVMetrics, but returns the "typographic" values from the OS/2 +// table (specific to MS/Windows TTF files). +// +// Returns 1 on success (table present), 0 on failure. + +STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1); +// the bounding box around all possible characters + +STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); +// leftSideBearing is the offset from the current horizontal position to the left edge of the character +// advanceWidth is the offset from the current horizontal position to the next horizontal position +// these are expressed in unscaled coordinates + +STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); +// an additional amount to add to the 'advance' value between ch1 and ch2 + +STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); +// Gets the bounding box of the visible part of the glyph, in unscaled coordinates + +STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); +STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); +// as above, but takes one or more glyph indices for greater efficiency + +typedef struct stbtt_kerningentry +{ + int glyph1; // use stbtt_FindGlyphIndex + int glyph2; + int advance; +} stbtt_kerningentry; + +STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info); +STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length); +// Retrieves a complete list of all of the kerning pairs provided by the font +// stbtt_GetKerningTable never writes more than table_length entries and returns how many entries it did write. +// The table will be sorted by (a.glyph1 == b.glyph1)?(a.glyph2 < b.glyph2):(a.glyph1 < b.glyph1) + +////////////////////////////////////////////////////////////////////////////// +// +// GLYPH SHAPES (you probably don't need these, but they have to go before +// the bitmaps for C declaration-order reasons) +// + +#ifndef STBTT_vmove // you can predefine these to use different values (but why?) + enum { + STBTT_vmove=1, + STBTT_vline, + STBTT_vcurve, + STBTT_vcubic + }; +#endif + +#ifndef stbtt_vertex // you can predefine this to use different values + // (we share this with other code at RAD) + #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file + typedef struct + { + stbtt_vertex_type x,y,cx,cy,cx1,cy1; + unsigned char type,padding; + } stbtt_vertex; +#endif + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index); +// returns non-zero if nothing is drawn for this glyph + +STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); +STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); +// returns # of vertices and fills *vertices with the pointer to them +// these are expressed in "unscaled" coordinates +// +// The shape is a series of contours. Each one starts with +// a STBTT_moveto, then consists of a series of mixed +// STBTT_lineto and STBTT_curveto segments. A lineto +// draws a line from previous endpoint to its x,y; a curveto +// draws a quadratic bezier from previous endpoint to +// its x,y, using cx,cy as the bezier control point. + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); +// frees the data allocated above + +STBTT_DEF unsigned char *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl); +STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg); +STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg); +// fills svg with the character's SVG data. +// returns data size or 0 if SVG not found. + +////////////////////////////////////////////////////////////////////////////// +// +// BITMAP RENDERING +// + +STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); +// frees the bitmap allocated below + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// allocates a large-enough single-channel 8bpp bitmap and renders the +// specified character/glyph at the specified scale into it, with +// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). +// *width & *height are filled out with the width & height of the bitmap, +// which is stored left-to-right, top-to-bottom. +// +// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// the same as stbtt_GetCodepoitnBitmap, but you can specify a subpixel +// shift for the character + +STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); +// the same as stbtt_GetCodepointBitmap, but you pass in storage for the bitmap +// in the form of 'output', with row spacing of 'out_stride' bytes. the bitmap +// is clipped to out_w/out_h bytes. Call stbtt_GetCodepointBitmapBox to get the +// width and height and positioning info for it first. + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint); +// same as stbtt_MakeCodepointBitmap, but you can specify a subpixel +// shift for the character + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint); +// same as stbtt_MakeCodepointBitmapSubpixel, but prefiltering +// is performed (see stbtt_PackSetOversampling) + +STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +// get the bbox of the bitmap centered around the glyph origin; so the +// bitmap width is ix1-ix0, height is iy1-iy0, and location to place +// the bitmap top left is (leftSideBearing*scale,iy0). +// (Note that the bitmap uses y-increases-down, but the shape uses +// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) + +STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); +// same as stbtt_GetCodepointBitmapBox, but you can specify a subpixel +// shift for the character + +// the following functions are equivalent to the above functions, but operate +// on glyph indices instead of Unicode codepoints (for efficiency) +STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph); +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int glyph); +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1); + + +// @TODO: don't expose this structure +typedef struct +{ + int w,h,stride; + unsigned char *pixels; +} stbtt__bitmap; + +// rasterize a shape with quadratic beziers into a bitmap +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, // 1-channel bitmap to draw into + float flatness_in_pixels, // allowable error of curve in pixels + stbtt_vertex *vertices, // array of vertices defining shape + int num_verts, // number of vertices in above array + float scale_x, float scale_y, // scale applied to input vertices + float shift_x, float shift_y, // translation applied to input vertices + int x_off, int y_off, // another translation applied to input + int invert, // if non-zero, vertically flip shape + void *userdata); // context for to STBTT_MALLOC + +////////////////////////////////////////////////////////////////////////////// +// +// Signed Distance Function (or Field) rendering + +STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata); +// frees the SDF bitmap allocated below + +STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff); +// These functions compute a discretized SDF field for a single character, suitable for storing +// in a single-channel texture, sampling with bilinear filtering, and testing against +// larger than some threshold to produce scalable fonts. +// info -- the font +// scale -- controls the size of the resulting SDF bitmap, same as it would be creating a regular bitmap +// glyph/codepoint -- the character to generate the SDF for +// padding -- extra "pixels" around the character which are filled with the distance to the character (not 0), +// which allows effects like bit outlines +// onedge_value -- value 0-255 to test the SDF against to reconstruct the character (i.e. the isocontour of the character) +// pixel_dist_scale -- what value the SDF should increase by when moving one SDF "pixel" away from the edge (on the 0..255 scale) +// if positive, > onedge_value is inside; if negative, < onedge_value is inside +// width,height -- output height & width of the SDF bitmap (including padding) +// xoff,yoff -- output origin of the character +// return value -- a 2D array of bytes 0..255, width*height in size +// +// pixel_dist_scale & onedge_value are a scale & bias that allows you to make +// optimal use of the limited 0..255 for your application, trading off precision +// and special effects. SDF values outside the range 0..255 are clamped to 0..255. +// +// Example: +// scale = stbtt_ScaleForPixelHeight(22) +// padding = 5 +// onedge_value = 180 +// pixel_dist_scale = 180/5.0 = 36.0 +// +// This will create an SDF bitmap in which the character is about 22 pixels +// high but the whole bitmap is about 22+5+5=32 pixels high. To produce a filled +// shape, sample the SDF at each pixel and fill the pixel if the SDF value +// is greater than or equal to 180/255. (You'll actually want to antialias, +// which is beyond the scope of this example.) Additionally, you can compute +// offset outlines (e.g. to stroke the character border inside & outside, +// or only outside). For example, to fill outside the character up to 3 SDF +// pixels, you would compare against (180-36.0*3)/255 = 72/255. The above +// choice of variables maps a range from 5 pixels outside the shape to +// 2 pixels inside the shape to 0..255; this is intended primarily for apply +// outside effects only (the interior range is needed to allow proper +// antialiasing of the font at *smaller* sizes) +// +// The function computes the SDF analytically at each SDF pixel, not by e.g. +// building a higher-res bitmap and approximating it. In theory the quality +// should be as high as possible for an SDF of this size & representation, but +// unclear if this is true in practice (perhaps building a higher-res bitmap +// and computing from that can allow drop-out prevention). +// +// The algorithm has not been optimized at all, so expect it to be slow +// if computing lots of characters or very large sizes. + + + +////////////////////////////////////////////////////////////////////////////// +// +// Finding the right font... +// +// You should really just solve this offline, keep your own tables +// of what font is what, and don't try to get it out of the .ttf file. +// That's because getting it out of the .ttf file is really hard, because +// the names in the file can appear in many possible encodings, in many +// possible languages, and e.g. if you need a case-insensitive comparison, +// the details of that depend on the encoding & language in a complex way +// (actually underspecified in truetype, but also gigantic). +// +// But you can use the provided functions in two possible ways: +// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on +// unicode-encoded names to try to find the font you want; +// you can run this before calling stbtt_InitFont() +// +// stbtt_GetFontNameString() lets you get any of the various strings +// from the file yourself and do your own comparisons on them. +// You have to have called stbtt_InitFont() first. + + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); +// returns the offset (not index) of the font that matches, or -1 if none +// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". +// if you use any other flag, use a font name like "Arial"; this checks +// the 'macStyle' header field; i don't know if fonts set this consistently +#define STBTT_MACSTYLE_DONTCARE 0 +#define STBTT_MACSTYLE_BOLD 1 +#define STBTT_MACSTYLE_ITALIC 2 +#define STBTT_MACSTYLE_UNDERSCORE 4 +#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 + +STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); +// returns 1/0 whether the first string interpreted as utf8 is identical to +// the second string interpreted as big-endian utf16... useful for strings from next func + +STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); +// returns the string (which may be big-endian double byte, e.g. for unicode) +// and puts the length in bytes in *length. +// +// some of the values for the IDs are below; for more see the truetype spec: +// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html +// http://www.microsoft.com/typography/otspec/name.htm + +enum { // platformID + STBTT_PLATFORM_ID_UNICODE =0, + STBTT_PLATFORM_ID_MAC =1, + STBTT_PLATFORM_ID_ISO =2, + STBTT_PLATFORM_ID_MICROSOFT =3 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_UNICODE + STBTT_UNICODE_EID_UNICODE_1_0 =0, + STBTT_UNICODE_EID_UNICODE_1_1 =1, + STBTT_UNICODE_EID_ISO_10646 =2, + STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, + STBTT_UNICODE_EID_UNICODE_2_0_FULL=4 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT + STBTT_MS_EID_SYMBOL =0, + STBTT_MS_EID_UNICODE_BMP =1, + STBTT_MS_EID_SHIFTJIS =2, + STBTT_MS_EID_UNICODE_FULL =10 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes + STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, + STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, + STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, + STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7 +}; + +enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... + // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs + STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, + STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, + STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, + STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, + STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, + STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D +}; + +enum { // languageID for STBTT_PLATFORM_ID_MAC + STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, + STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, + STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, + STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , + STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , + STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, + STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19 +}; + +#ifdef __cplusplus +} +#endif + +#endif // __STB_INCLUDE_STB_TRUETYPE_H__ + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// IMPLEMENTATION +//// +//// + +#ifdef STB_TRUETYPE_IMPLEMENTATION + +#ifndef STBTT_MAX_OVERSAMPLE +#define STBTT_MAX_OVERSAMPLE 8 +#endif + +#if STBTT_MAX_OVERSAMPLE > 255 +#error "STBTT_MAX_OVERSAMPLE cannot be > 255" +#endif + +typedef int stbtt__test_oversample_pow2[(STBTT_MAX_OVERSAMPLE & (STBTT_MAX_OVERSAMPLE-1)) == 0 ? 1 : -1]; + +#ifndef STBTT_RASTERIZER_VERSION +#define STBTT_RASTERIZER_VERSION 2 +#endif + +#ifdef _MSC_VER +#define STBTT__NOTUSED(v) (void)(v) +#else +#define STBTT__NOTUSED(v) (void)sizeof(v) +#endif + +////////////////////////////////////////////////////////////////////////// +// +// stbtt__buf helpers to parse data from file +// + +static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b) +{ + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor++]; +} + +static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b) +{ + if (b->cursor >= b->size) + return 0; + return b->data[b->cursor]; +} + +static void stbtt__buf_seek(stbtt__buf *b, int o) +{ + STBTT_assert(!(o > b->size || o < 0)); + b->cursor = (o > b->size || o < 0) ? b->size : o; +} + +static void stbtt__buf_skip(stbtt__buf *b, int o) +{ + stbtt__buf_seek(b, b->cursor + o); +} + +static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n) +{ + stbtt_uint32 v = 0; + int i; + STBTT_assert(n >= 1 && n <= 4); + for (i = 0; i < n; i++) + v = (v << 8) | stbtt__buf_get8(b); + return v; +} + +static stbtt__buf stbtt__new_buf(const void *p, size_t size) +{ + stbtt__buf r; + STBTT_assert(size < 0x40000000); + r.data = (stbtt_uint8*) p; + r.size = (int) size; + r.cursor = 0; + return r; +} + +#define stbtt__buf_get16(b) stbtt__buf_get((b), 2) +#define stbtt__buf_get32(b) stbtt__buf_get((b), 4) + +static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s) +{ + stbtt__buf r = stbtt__new_buf(NULL, 0); + if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r; + r.data = b->data + o; + r.size = s; + return r; +} + +static stbtt__buf stbtt__cff_get_index(stbtt__buf *b) +{ + int count, start, offsize; + start = b->cursor; + count = stbtt__buf_get16(b); + if (count) { + offsize = stbtt__buf_get8(b); + STBTT_assert(offsize >= 1 && offsize <= 4); + stbtt__buf_skip(b, offsize * count); + stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1); + } + return stbtt__buf_range(b, start, b->cursor - start); +} + +static stbtt_uint32 stbtt__cff_int(stbtt__buf *b) +{ + int b0 = stbtt__buf_get8(b); + if (b0 >= 32 && b0 <= 246) return b0 - 139; + else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108; + else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108; + else if (b0 == 28) return stbtt__buf_get16(b); + else if (b0 == 29) return stbtt__buf_get32(b); + STBTT_assert(0); + return 0; +} + +static void stbtt__cff_skip_operand(stbtt__buf *b) { + int v, b0 = stbtt__buf_peek8(b); + STBTT_assert(b0 >= 28); + if (b0 == 30) { + stbtt__buf_skip(b, 1); + while (b->cursor < b->size) { + v = stbtt__buf_get8(b); + if ((v & 0xF) == 0xF || (v >> 4) == 0xF) + break; + } + } else { + stbtt__cff_int(b); + } +} + +static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key) +{ + stbtt__buf_seek(b, 0); + while (b->cursor < b->size) { + int start = b->cursor, end, op; + while (stbtt__buf_peek8(b) >= 28) + stbtt__cff_skip_operand(b); + end = b->cursor; + op = stbtt__buf_get8(b); + if (op == 12) op = stbtt__buf_get8(b) | 0x100; + if (op == key) return stbtt__buf_range(b, start, end-start); + } + return stbtt__buf_range(b, 0, 0); +} + +static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out) +{ + int i; + stbtt__buf operands = stbtt__dict_get(b, key); + for (i = 0; i < outcount && operands.cursor < operands.size; i++) + out[i] = stbtt__cff_int(&operands); +} + +static int stbtt__cff_index_count(stbtt__buf *b) +{ + stbtt__buf_seek(b, 0); + return stbtt__buf_get16(b); +} + +static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i) +{ + int count, offsize, start, end; + stbtt__buf_seek(&b, 0); + count = stbtt__buf_get16(&b); + offsize = stbtt__buf_get8(&b); + STBTT_assert(i >= 0 && i < count); + STBTT_assert(offsize >= 1 && offsize <= 4); + stbtt__buf_skip(&b, i*offsize); + start = stbtt__buf_get(&b, offsize); + end = stbtt__buf_get(&b, offsize); + return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start); +} + +////////////////////////////////////////////////////////////////////////// +// +// accessors to parse data from file +// + +// on platforms that don't allow misaligned reads, if we want to allow +// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE + +#define ttBYTE(p) (* (stbtt_uint8 *) (p)) +#define ttCHAR(p) (* (stbtt_int8 *) (p)) +#define ttFixed(p) ttLONG(p) + +static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } +static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; } +static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } +static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + +#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) +#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) + +static int stbtt__isfont(stbtt_uint8 *font) +{ + // check the version number + if (stbtt_tag4(font, '1',0,0,0)) return 1; // TrueType 1 + if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! + if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF + if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 + if (stbtt_tag(font, "true")) return 1; // Apple specification for TrueType fonts + return 0; +} + +// @OPTIMIZE: binary search +static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag) +{ + stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); + stbtt_uint32 tabledir = fontstart + 12; + stbtt_int32 i; + for (i=0; i < num_tables; ++i) { + stbtt_uint32 loc = tabledir + 16*i; + if (stbtt_tag(data+loc+0, tag)) + return ttULONG(data+loc+8); + } + return 0; +} + +static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index) +{ + // if it's just a font, there's only one valid index + if (stbtt__isfont(font_collection)) + return index == 0 ? 0 : -1; + + // check if it's a TTC + if (stbtt_tag(font_collection, "ttcf")) { + // version 1? + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + stbtt_int32 n = ttLONG(font_collection+8); + if (index >= n) + return -1; + return ttULONG(font_collection+12+index*4); + } + } + return -1; +} + +static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection) +{ + // if it's just a font, there's only one valid font + if (stbtt__isfont(font_collection)) + return 1; + + // check if it's a TTC + if (stbtt_tag(font_collection, "ttcf")) { + // version 1? + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + return ttLONG(font_collection+8); + } + } + return 0; +} + +static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict) +{ + stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 }; + stbtt__buf pdict; + stbtt__dict_get_ints(&fontdict, 18, 2, private_loc); + if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0); + pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]); + stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff); + if (!subrsoff) return stbtt__new_buf(NULL, 0); + stbtt__buf_seek(&cff, private_loc[1]+subrsoff); + return stbtt__cff_get_index(&cff); +} + +// since most people won't use this, find this table the first time it's needed +static int stbtt__get_svg(stbtt_fontinfo *info) +{ + stbtt_uint32 t; + if (info->svg < 0) { + t = stbtt__find_table(info->data, info->fontstart, "SVG "); + if (t) { + stbtt_uint32 offset = ttULONG(info->data + t + 2); + info->svg = t + offset; + } else { + info->svg = 0; + } + } + return info->svg; +} + +static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *data, int fontstart) +{ + stbtt_uint32 cmap, t; + stbtt_int32 i,numTables; + + info->data = data; + info->fontstart = fontstart; + info->cff = stbtt__new_buf(NULL, 0); + + cmap = stbtt__find_table(data, fontstart, "cmap"); // required + info->loca = stbtt__find_table(data, fontstart, "loca"); // required + info->head = stbtt__find_table(data, fontstart, "head"); // required + info->glyf = stbtt__find_table(data, fontstart, "glyf"); // required + info->hhea = stbtt__find_table(data, fontstart, "hhea"); // required + info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); // required + info->kern = stbtt__find_table(data, fontstart, "kern"); // not required + info->gpos = stbtt__find_table(data, fontstart, "GPOS"); // not required + + if (!cmap || !info->head || !info->hhea || !info->hmtx) + return 0; + if (info->glyf) { + // required for truetype + if (!info->loca) return 0; + } else { + // initialization for CFF / Type2 fonts (OTF) + stbtt__buf b, topdict, topdictidx; + stbtt_uint32 cstype = 2, charstrings = 0, fdarrayoff = 0, fdselectoff = 0; + stbtt_uint32 cff; + + cff = stbtt__find_table(data, fontstart, "CFF "); + if (!cff) return 0; + + info->fontdicts = stbtt__new_buf(NULL, 0); + info->fdselect = stbtt__new_buf(NULL, 0); + + // @TODO this should use size from table (not 512MB) + info->cff = stbtt__new_buf(data+cff, 512*1024*1024); + b = info->cff; + + // read the header + stbtt__buf_skip(&b, 2); + stbtt__buf_seek(&b, stbtt__buf_get8(&b)); // hdrsize + + // @TODO the name INDEX could list multiple fonts, + // but we just use the first one. + stbtt__cff_get_index(&b); // name INDEX + topdictidx = stbtt__cff_get_index(&b); + topdict = stbtt__cff_index_get(topdictidx, 0); + stbtt__cff_get_index(&b); // string INDEX + info->gsubrs = stbtt__cff_get_index(&b); + + stbtt__dict_get_ints(&topdict, 17, 1, &charstrings); + stbtt__dict_get_ints(&topdict, 0x100 | 6, 1, &cstype); + stbtt__dict_get_ints(&topdict, 0x100 | 36, 1, &fdarrayoff); + stbtt__dict_get_ints(&topdict, 0x100 | 37, 1, &fdselectoff); + info->subrs = stbtt__get_subrs(b, topdict); + + // we only support Type 2 charstrings + if (cstype != 2) return 0; + if (charstrings == 0) return 0; + + if (fdarrayoff) { + // looks like a CID font + if (!fdselectoff) return 0; + stbtt__buf_seek(&b, fdarrayoff); + info->fontdicts = stbtt__cff_get_index(&b); + info->fdselect = stbtt__buf_range(&b, fdselectoff, b.size-fdselectoff); + } + + stbtt__buf_seek(&b, charstrings); + info->charstrings = stbtt__cff_get_index(&b); + } + + t = stbtt__find_table(data, fontstart, "maxp"); + if (t) + info->numGlyphs = ttUSHORT(data+t+4); + else + info->numGlyphs = 0xffff; + + info->svg = -1; + + // find a cmap encoding table we understand *now* to avoid searching + // later. (todo: could make this installable) + // the same regardless of glyph. + numTables = ttUSHORT(data + cmap + 2); + info->index_map = 0; + for (i=0; i < numTables; ++i) { + stbtt_uint32 encoding_record = cmap + 4 + 8 * i; + // find an encoding we understand: + switch(ttUSHORT(data+encoding_record)) { + case STBTT_PLATFORM_ID_MICROSOFT: + switch (ttUSHORT(data+encoding_record+2)) { + case STBTT_MS_EID_UNICODE_BMP: + case STBTT_MS_EID_UNICODE_FULL: + // MS/Unicode + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + break; + case STBTT_PLATFORM_ID_UNICODE: + // Mac/iOS has these + // all the encodingIDs are unicode, so we don't bother to check it + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + } + if (info->index_map == 0) + return 0; + + info->indexToLocFormat = ttUSHORT(data+info->head + 50); + return 1; +} + +STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) +{ + stbtt_uint8 *data = info->data; + stbtt_uint32 index_map = info->index_map; + + stbtt_uint16 format = ttUSHORT(data + index_map + 0); + if (format == 0) { // apple byte encoding + stbtt_int32 bytes = ttUSHORT(data + index_map + 2); + if (unicode_codepoint < bytes-6) + return ttBYTE(data + index_map + 6 + unicode_codepoint); + return 0; + } else if (format == 6) { + stbtt_uint32 first = ttUSHORT(data + index_map + 6); + stbtt_uint32 count = ttUSHORT(data + index_map + 8); + if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) + return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); + return 0; + } else if (format == 2) { + STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean + return 0; + } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges + stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; + stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; + stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); + stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; + + // do a binary search of the segments + stbtt_uint32 endCount = index_map + 14; + stbtt_uint32 search = endCount; + + if (unicode_codepoint > 0xffff) + return 0; + + // they lie from endCount .. endCount + segCount + // but searchRange is the nearest power of two, so... + if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) + search += rangeShift*2; + + // now decrement to bias correctly to find smallest + search -= 2; + while (entrySelector) { + stbtt_uint16 end; + searchRange >>= 1; + end = ttUSHORT(data + search + searchRange*2); + if (unicode_codepoint > end) + search += searchRange*2; + --entrySelector; + } + search += 2; + + { + stbtt_uint16 offset, start, last; + stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1); + + start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); + last = ttUSHORT(data + endCount + 2*item); + if (unicode_codepoint < start || unicode_codepoint > last) + return 0; + + offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); + if (offset == 0) + return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item)); + + return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); + } + } else if (format == 12 || format == 13) { + stbtt_uint32 ngroups = ttULONG(data+index_map+12); + stbtt_int32 low,high; + low = 0; high = (stbtt_int32)ngroups; + // Binary search the right group. + while (low < high) { + stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high + stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); + stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); + if ((stbtt_uint32) unicode_codepoint < start_char) + high = mid; + else if ((stbtt_uint32) unicode_codepoint > end_char) + low = mid+1; + else { + stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); + if (format == 12) + return start_glyph + unicode_codepoint-start_char; + else // format == 13 + return start_glyph; + } + } + return 0; // not found + } + // @TODO + STBTT_assert(0); + return 0; +} + +STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) +{ + return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); +} + +static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy) +{ + v->type = type; + v->x = (stbtt_int16) x; + v->y = (stbtt_int16) y; + v->cx = (stbtt_int16) cx; + v->cy = (stbtt_int16) cy; +} + +static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) +{ + int g1,g2; + + STBTT_assert(!info->cff.size); + + if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range + if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format + + if (info->indexToLocFormat == 0) { + g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; + g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; + } else { + g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); + g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); + } + + return g1==g2 ? -1 : g1; // if length is 0, return -1 +} + +static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); + +STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + if (info->cff.size) { + stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1); + } else { + int g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 0; + + if (x0) *x0 = ttSHORT(info->data + g + 2); + if (y0) *y0 = ttSHORT(info->data + g + 4); + if (x1) *x1 = ttSHORT(info->data + g + 6); + if (y1) *y1 = ttSHORT(info->data + g + 8); + } + return 1; +} + +STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) +{ + return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); +} + +STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index) +{ + stbtt_int16 numberOfContours; + int g; + if (info->cff.size) + return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0; + g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 1; + numberOfContours = ttSHORT(info->data + g); + return numberOfContours == 0; +} + +static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off, + stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy) +{ + if (start_off) { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1, (cy+scy)>>1, cx,cy); + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, sx,sy,scx,scy); + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); + } + return num_vertices; +} + +static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + stbtt_int16 numberOfContours; + stbtt_uint8 *endPtsOfContours; + stbtt_uint8 *data = info->data; + stbtt_vertex *vertices=0; + int num_vertices=0; + int g = stbtt__GetGlyfOffset(info, glyph_index); + + *pvertices = NULL; + + if (g < 0) return 0; + + numberOfContours = ttSHORT(data + g); + + if (numberOfContours > 0) { + stbtt_uint8 flags=0,flagcount; + stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off, start_off=0; + stbtt_int32 x,y,cx,cy,sx,sy, scx,scy; + stbtt_uint8 *points; + endPtsOfContours = (data + g + 10); + ins = ttUSHORT(data + g + 10 + numberOfContours * 2); + points = data + g + 10 + numberOfContours * 2 + 2 + ins; + + n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); + + m = n + 2*numberOfContours; // a loose bound on how many vertices we might need + vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); + if (vertices == 0) + return 0; + + next_move = 0; + flagcount=0; + + // in first pass, we load uninterpreted data into the allocated array + // above, shifted to the end of the array so we won't overwrite it when + // we create our final data starting from the front + + off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated + + // first load flags + + for (i=0; i < n; ++i) { + if (flagcount == 0) { + flags = *points++; + if (flags & 8) + flagcount = *points++; + } else + --flagcount; + vertices[off+i].type = flags; + } + + // now load x coordinates + x=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 2) { + stbtt_int16 dx = *points++; + x += (flags & 16) ? dx : -dx; // ??? + } else { + if (!(flags & 16)) { + x = x + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].x = (stbtt_int16) x; + } + + // now load y coordinates + y=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 4) { + stbtt_int16 dy = *points++; + y += (flags & 32) ? dy : -dy; // ??? + } else { + if (!(flags & 32)) { + y = y + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].y = (stbtt_int16) y; + } + + // now convert them to our format + num_vertices=0; + sx = sy = cx = cy = scx = scy = 0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + x = (stbtt_int16) vertices[off+i].x; + y = (stbtt_int16) vertices[off+i].y; + + if (next_move == i) { + if (i != 0) + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + + // now start the new one + start_off = !(flags & 1); + if (start_off) { + // if we start off with an off-curve point, then when we need to find a point on the curve + // where we can start, and we need to save some state for when we wraparound. + scx = x; + scy = y; + if (!(vertices[off+i+1].type & 1)) { + // next point is also a curve point, so interpolate an on-point curve + sx = (x + (stbtt_int32) vertices[off+i+1].x) >> 1; + sy = (y + (stbtt_int32) vertices[off+i+1].y) >> 1; + } else { + // otherwise just use the next point as our start point + sx = (stbtt_int32) vertices[off+i+1].x; + sy = (stbtt_int32) vertices[off+i+1].y; + ++i; // we're using point i+1 as the starting point, so skip it + } + } else { + sx = x; + sy = y; + } + stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,sx,sy,0,0); + was_off = 0; + next_move = 1 + ttUSHORT(endPtsOfContours+j*2); + ++j; + } else { + if (!(flags & 1)) { // if it's a curve + if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); + cx = x; + cy = y; + was_off = 1; + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); + was_off = 0; + } + } + } + num_vertices = stbtt__close_shape(vertices, num_vertices, was_off, start_off, sx,sy,scx,scy,cx,cy); + } else if (numberOfContours < 0) { + // Compound shapes. + int more = 1; + stbtt_uint8 *comp = data + g + 10; + num_vertices = 0; + vertices = 0; + while (more) { + stbtt_uint16 flags, gidx; + int comp_num_verts = 0, i; + stbtt_vertex *comp_verts = 0, *tmp = 0; + float mtx[6] = {1,0,0,1,0,0}, m, n; + + flags = ttSHORT(comp); comp+=2; + gidx = ttSHORT(comp); comp+=2; + + if (flags & 2) { // XY values + if (flags & 1) { // shorts + mtx[4] = ttSHORT(comp); comp+=2; + mtx[5] = ttSHORT(comp); comp+=2; + } else { + mtx[4] = ttCHAR(comp); comp+=1; + mtx[5] = ttCHAR(comp); comp+=1; + } + } + else { + // @TODO handle matching point + STBTT_assert(0); + } + if (flags & (1<<3)) { // WE_HAVE_A_SCALE + mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } + + // Find transformation scales. + m = (float) STBTT_sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); + n = (float) STBTT_sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); + + // Get indexed glyph. + comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); + if (comp_num_verts > 0) { + // Transform vertices. + for (i = 0; i < comp_num_verts; ++i) { + stbtt_vertex* v = &comp_verts[i]; + stbtt_vertex_type x,y; + x=v->x; y=v->y; + v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + x=v->cx; y=v->cy; + v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + } + // Append vertices. + tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); + if (!tmp) { + if (vertices) STBTT_free(vertices, info->userdata); + if (comp_verts) STBTT_free(comp_verts, info->userdata); + return 0; + } + if (num_vertices > 0 && vertices) STBTT_memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); + STBTT_memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); + if (vertices) STBTT_free(vertices, info->userdata); + vertices = tmp; + STBTT_free(comp_verts, info->userdata); + num_vertices += comp_num_verts; + } + // More components ? + more = flags & (1<<5); + } + } else { + // numberOfCounters == 0, do nothing + } + + *pvertices = vertices; + return num_vertices; +} + +typedef struct +{ + int bounds; + int started; + float first_x, first_y; + float x, y; + stbtt_int32 min_x, max_x, min_y, max_y; + + stbtt_vertex *pvertices; + int num_vertices; +} stbtt__csctx; + +#define STBTT__CSCTX_INIT(bounds) {bounds,0, 0,0, 0,0, 0,0,0,0, NULL, 0} + +static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y) +{ + if (x > c->max_x || !c->started) c->max_x = x; + if (y > c->max_y || !c->started) c->max_y = y; + if (x < c->min_x || !c->started) c->min_x = x; + if (y < c->min_y || !c->started) c->min_y = y; + c->started = 1; +} + +static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1) +{ + if (c->bounds) { + stbtt__track_vertex(c, x, y); + if (type == STBTT_vcubic) { + stbtt__track_vertex(c, cx, cy); + stbtt__track_vertex(c, cx1, cy1); + } + } else { + stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy); + c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1; + c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1; + } + c->num_vertices++; +} + +static void stbtt__csctx_close_shape(stbtt__csctx *ctx) +{ + if (ctx->first_x != ctx->x || ctx->first_y != ctx->y) + stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->first_x, (int)ctx->first_y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy) +{ + stbtt__csctx_close_shape(ctx); + ctx->first_x = ctx->x = ctx->x + dx; + ctx->first_y = ctx->y = ctx->y + dy; + stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy) +{ + ctx->x += dx; + ctx->y += dy; + stbtt__csctx_v(ctx, STBTT_vline, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0); +} + +static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3) +{ + float cx1 = ctx->x + dx1; + float cy1 = ctx->y + dy1; + float cx2 = cx1 + dx2; + float cy2 = cy1 + dy2; + ctx->x = cx2 + dx3; + ctx->y = cy2 + dy3; + stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2); +} + +static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n) +{ + int count = stbtt__cff_index_count(&idx); + int bias = 107; + if (count >= 33900) + bias = 32768; + else if (count >= 1240) + bias = 1131; + n += bias; + if (n < 0 || n >= count) + return stbtt__new_buf(NULL, 0); + return stbtt__cff_index_get(idx, n); +} + +static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index) +{ + stbtt__buf fdselect = info->fdselect; + int nranges, start, end, v, fmt, fdselector = -1, i; + + stbtt__buf_seek(&fdselect, 0); + fmt = stbtt__buf_get8(&fdselect); + if (fmt == 0) { + // untested + stbtt__buf_skip(&fdselect, glyph_index); + fdselector = stbtt__buf_get8(&fdselect); + } else if (fmt == 3) { + nranges = stbtt__buf_get16(&fdselect); + start = stbtt__buf_get16(&fdselect); + for (i = 0; i < nranges; i++) { + v = stbtt__buf_get8(&fdselect); + end = stbtt__buf_get16(&fdselect); + if (glyph_index >= start && glyph_index < end) { + fdselector = v; + break; + } + start = end; + } + } + if (fdselector == -1) stbtt__new_buf(NULL, 0); + return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector)); +} + +static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_index, stbtt__csctx *c) +{ + int in_header = 1, maskbits = 0, subr_stack_height = 0, sp = 0, v, i, b0; + int has_subrs = 0, clear_stack; + float s[48]; + stbtt__buf subr_stack[10], subrs = info->subrs, b; + float f; + +#define STBTT__CSERR(s) (0) + + // this currently ignores the initial width value, which isn't needed if we have hmtx + b = stbtt__cff_index_get(info->charstrings, glyph_index); + while (b.cursor < b.size) { + i = 0; + clear_stack = 1; + b0 = stbtt__buf_get8(&b); + switch (b0) { + // @TODO implement hinting + case 0x13: // hintmask + case 0x14: // cntrmask + if (in_header) + maskbits += (sp / 2); // implicit "vstem" + in_header = 0; + stbtt__buf_skip(&b, (maskbits + 7) / 8); + break; + + case 0x01: // hstem + case 0x03: // vstem + case 0x12: // hstemhm + case 0x17: // vstemhm + maskbits += (sp / 2); + break; + + case 0x15: // rmoveto + in_header = 0; + if (sp < 2) return STBTT__CSERR("rmoveto stack"); + stbtt__csctx_rmove_to(c, s[sp-2], s[sp-1]); + break; + case 0x04: // vmoveto + in_header = 0; + if (sp < 1) return STBTT__CSERR("vmoveto stack"); + stbtt__csctx_rmove_to(c, 0, s[sp-1]); + break; + case 0x16: // hmoveto + in_header = 0; + if (sp < 1) return STBTT__CSERR("hmoveto stack"); + stbtt__csctx_rmove_to(c, s[sp-1], 0); + break; + + case 0x05: // rlineto + if (sp < 2) return STBTT__CSERR("rlineto stack"); + for (; i + 1 < sp; i += 2) + stbtt__csctx_rline_to(c, s[i], s[i+1]); + break; + + // hlineto/vlineto and vhcurveto/hvcurveto alternate horizontal and vertical + // starting from a different place. + + case 0x07: // vlineto + if (sp < 1) return STBTT__CSERR("vlineto stack"); + goto vlineto; + case 0x06: // hlineto + if (sp < 1) return STBTT__CSERR("hlineto stack"); + for (;;) { + if (i >= sp) break; + stbtt__csctx_rline_to(c, s[i], 0); + i++; + vlineto: + if (i >= sp) break; + stbtt__csctx_rline_to(c, 0, s[i]); + i++; + } + break; + + case 0x1F: // hvcurveto + if (sp < 4) return STBTT__CSERR("hvcurveto stack"); + goto hvcurveto; + case 0x1E: // vhcurveto + if (sp < 4) return STBTT__CSERR("vhcurveto stack"); + for (;;) { + if (i + 3 >= sp) break; + stbtt__csctx_rccurve_to(c, 0, s[i], s[i+1], s[i+2], s[i+3], (sp - i == 5) ? s[i + 4] : 0.0f); + i += 4; + hvcurveto: + if (i + 3 >= sp) break; + stbtt__csctx_rccurve_to(c, s[i], 0, s[i+1], s[i+2], (sp - i == 5) ? s[i+4] : 0.0f, s[i+3]); + i += 4; + } + break; + + case 0x08: // rrcurveto + if (sp < 6) return STBTT__CSERR("rcurveline stack"); + for (; i + 5 < sp; i += 6) + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + break; + + case 0x18: // rcurveline + if (sp < 8) return STBTT__CSERR("rcurveline stack"); + for (; i + 5 < sp - 2; i += 6) + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + if (i + 1 >= sp) return STBTT__CSERR("rcurveline stack"); + stbtt__csctx_rline_to(c, s[i], s[i+1]); + break; + + case 0x19: // rlinecurve + if (sp < 8) return STBTT__CSERR("rlinecurve stack"); + for (; i + 1 < sp - 6; i += 2) + stbtt__csctx_rline_to(c, s[i], s[i+1]); + if (i + 5 >= sp) return STBTT__CSERR("rlinecurve stack"); + stbtt__csctx_rccurve_to(c, s[i], s[i+1], s[i+2], s[i+3], s[i+4], s[i+5]); + break; + + case 0x1A: // vvcurveto + case 0x1B: // hhcurveto + if (sp < 4) return STBTT__CSERR("(vv|hh)curveto stack"); + f = 0.0; + if (sp & 1) { f = s[i]; i++; } + for (; i + 3 < sp; i += 4) { + if (b0 == 0x1B) + stbtt__csctx_rccurve_to(c, s[i], f, s[i+1], s[i+2], s[i+3], 0.0); + else + stbtt__csctx_rccurve_to(c, f, s[i], s[i+1], s[i+2], 0.0, s[i+3]); + f = 0.0; + } + break; + + case 0x0A: // callsubr + if (!has_subrs) { + if (info->fdselect.size) + subrs = stbtt__cid_get_glyph_subrs(info, glyph_index); + has_subrs = 1; + } + // FALLTHROUGH + case 0x1D: // callgsubr + if (sp < 1) return STBTT__CSERR("call(g|)subr stack"); + v = (int) s[--sp]; + if (subr_stack_height >= 10) return STBTT__CSERR("recursion limit"); + subr_stack[subr_stack_height++] = b; + b = stbtt__get_subr(b0 == 0x0A ? subrs : info->gsubrs, v); + if (b.size == 0) return STBTT__CSERR("subr not found"); + b.cursor = 0; + clear_stack = 0; + break; + + case 0x0B: // return + if (subr_stack_height <= 0) return STBTT__CSERR("return outside subr"); + b = subr_stack[--subr_stack_height]; + clear_stack = 0; + break; + + case 0x0E: // endchar + stbtt__csctx_close_shape(c); + return 1; + + case 0x0C: { // two-byte escape + float dx1, dx2, dx3, dx4, dx5, dx6, dy1, dy2, dy3, dy4, dy5, dy6; + float dx, dy; + int b1 = stbtt__buf_get8(&b); + switch (b1) { + // @TODO These "flex" implementations ignore the flex-depth and resolution, + // and always draw beziers. + case 0x22: // hflex + if (sp < 7) return STBTT__CSERR("hflex stack"); + dx1 = s[0]; + dx2 = s[1]; + dy2 = s[2]; + dx3 = s[3]; + dx4 = s[4]; + dx5 = s[5]; + dx6 = s[6]; + stbtt__csctx_rccurve_to(c, dx1, 0, dx2, dy2, dx3, 0); + stbtt__csctx_rccurve_to(c, dx4, 0, dx5, -dy2, dx6, 0); + break; + + case 0x23: // flex + if (sp < 13) return STBTT__CSERR("flex stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dy3 = s[5]; + dx4 = s[6]; + dy4 = s[7]; + dx5 = s[8]; + dy5 = s[9]; + dx6 = s[10]; + dy6 = s[11]; + //fd is s[12] + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); + stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); + break; + + case 0x24: // hflex1 + if (sp < 9) return STBTT__CSERR("hflex1 stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dx4 = s[5]; + dx5 = s[6]; + dy5 = s[7]; + dx6 = s[8]; + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, 0); + stbtt__csctx_rccurve_to(c, dx4, 0, dx5, dy5, dx6, -(dy1+dy2+dy5)); + break; + + case 0x25: // flex1 + if (sp < 11) return STBTT__CSERR("flex1 stack"); + dx1 = s[0]; + dy1 = s[1]; + dx2 = s[2]; + dy2 = s[3]; + dx3 = s[4]; + dy3 = s[5]; + dx4 = s[6]; + dy4 = s[7]; + dx5 = s[8]; + dy5 = s[9]; + dx6 = dy6 = s[10]; + dx = dx1+dx2+dx3+dx4+dx5; + dy = dy1+dy2+dy3+dy4+dy5; + if (STBTT_fabs(dx) > STBTT_fabs(dy)) + dy6 = -dy; + else + dx6 = -dx; + stbtt__csctx_rccurve_to(c, dx1, dy1, dx2, dy2, dx3, dy3); + stbtt__csctx_rccurve_to(c, dx4, dy4, dx5, dy5, dx6, dy6); + break; + + default: + return STBTT__CSERR("unimplemented"); + } + } break; + + default: + if (b0 != 255 && b0 != 28 && b0 < 32) + return STBTT__CSERR("reserved operator"); + + // push immediate + if (b0 == 255) { + f = (float)(stbtt_int32)stbtt__buf_get32(&b) / 0x10000; + } else { + stbtt__buf_skip(&b, -1); + f = (float)(stbtt_int16)stbtt__cff_int(&b); + } + if (sp >= 48) return STBTT__CSERR("push stack overflow"); + s[sp++] = f; + clear_stack = 0; + break; + } + if (clear_stack) sp = 0; + } + return STBTT__CSERR("no endchar"); + +#undef STBTT__CSERR +} + +static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + // runs the charstring twice, once to count and once to output (to avoid realloc) + stbtt__csctx count_ctx = STBTT__CSCTX_INIT(1); + stbtt__csctx output_ctx = STBTT__CSCTX_INIT(0); + if (stbtt__run_charstring(info, glyph_index, &count_ctx)) { + *pvertices = (stbtt_vertex*)STBTT_malloc(count_ctx.num_vertices*sizeof(stbtt_vertex), info->userdata); + output_ctx.pvertices = *pvertices; + if (stbtt__run_charstring(info, glyph_index, &output_ctx)) { + STBTT_assert(output_ctx.num_vertices == count_ctx.num_vertices); + return output_ctx.num_vertices; + } + } + *pvertices = NULL; + return 0; +} + +static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + stbtt__csctx c = STBTT__CSCTX_INIT(1); + int r = stbtt__run_charstring(info, glyph_index, &c); + if (x0) *x0 = r ? c.min_x : 0; + if (y0) *y0 = r ? c.min_y : 0; + if (x1) *x1 = r ? c.max_x : 0; + if (y1) *y1 = r ? c.max_y : 0; + return r ? c.num_vertices : 0; +} + +STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + if (!info->cff.size) + return stbtt__GetGlyphShapeTT(info, glyph_index, pvertices); + else + return stbtt__GetGlyphShapeT2(info, glyph_index, pvertices); +} + +STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) +{ + stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); + if (glyph_index < numOfLongHorMetrics) { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); + } else { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); + } +} + +STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info) +{ + stbtt_uint8 *data = info->data + info->kern; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + return ttUSHORT(data+10); +} + +STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_kerningentry* table, int table_length) +{ + stbtt_uint8 *data = info->data + info->kern; + int k, length; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + length = ttUSHORT(data+10); + if (table_length < length) + length = table_length; + + for (k = 0; k < length; k++) + { + table[k].glyph1 = ttUSHORT(data+18+(k*6)); + table[k].glyph2 = ttUSHORT(data+20+(k*6)); + table[k].advance = ttSHORT(data+22+(k*6)); + } + + return length; +} + +static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + stbtt_uint8 *data = info->data + info->kern; + stbtt_uint32 needle, straw; + int l, r, m; + + // we only look at the first table. it must be 'horizontal' and format 0. + if (!info->kern) + return 0; + if (ttUSHORT(data+2) < 1) // number of tables, need at least 1 + return 0; + if (ttUSHORT(data+8) != 1) // horizontal flag must be set in format + return 0; + + l = 0; + r = ttUSHORT(data+10) - 1; + needle = glyph1 << 16 | glyph2; + while (l <= r) { + m = (l + r) >> 1; + straw = ttULONG(data+18+(m*6)); // note: unaligned read + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else + return ttSHORT(data+22+(m*6)); + } + return 0; +} + +static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, int glyph) +{ + stbtt_uint16 coverageFormat = ttUSHORT(coverageTable); + switch (coverageFormat) { + case 1: { + stbtt_uint16 glyphCount = ttUSHORT(coverageTable + 2); + + // Binary search. + stbtt_int32 l=0, r=glyphCount-1, m; + int straw, needle=glyph; + while (l <= r) { + stbtt_uint8 *glyphArray = coverageTable + 4; + stbtt_uint16 glyphID; + m = (l + r) >> 1; + glyphID = ttUSHORT(glyphArray + 2 * m); + straw = glyphID; + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else { + return m; + } + } + break; + } + + case 2: { + stbtt_uint16 rangeCount = ttUSHORT(coverageTable + 2); + stbtt_uint8 *rangeArray = coverageTable + 4; + + // Binary search. + stbtt_int32 l=0, r=rangeCount-1, m; + int strawStart, strawEnd, needle=glyph; + while (l <= r) { + stbtt_uint8 *rangeRecord; + m = (l + r) >> 1; + rangeRecord = rangeArray + 6 * m; + strawStart = ttUSHORT(rangeRecord); + strawEnd = ttUSHORT(rangeRecord + 2); + if (needle < strawStart) + r = m - 1; + else if (needle > strawEnd) + l = m + 1; + else { + stbtt_uint16 startCoverageIndex = ttUSHORT(rangeRecord + 4); + return startCoverageIndex + glyph - strawStart; + } + } + break; + } + + default: return -1; // unsupported + } + + return -1; +} + +static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph) +{ + stbtt_uint16 classDefFormat = ttUSHORT(classDefTable); + switch (classDefFormat) + { + case 1: { + stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2); + stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4); + stbtt_uint8 *classDef1ValueArray = classDefTable + 6; + + if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount) + return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID)); + break; + } + + case 2: { + stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2); + stbtt_uint8 *classRangeRecords = classDefTable + 4; + + // Binary search. + stbtt_int32 l=0, r=classRangeCount-1, m; + int strawStart, strawEnd, needle=glyph; + while (l <= r) { + stbtt_uint8 *classRangeRecord; + m = (l + r) >> 1; + classRangeRecord = classRangeRecords + 6 * m; + strawStart = ttUSHORT(classRangeRecord); + strawEnd = ttUSHORT(classRangeRecord + 2); + if (needle < strawStart) + r = m - 1; + else if (needle > strawEnd) + l = m + 1; + else + return (stbtt_int32)ttUSHORT(classRangeRecord + 4); + } + break; + } + + default: + return -1; // Unsupported definition type, return an error. + } + + // "All glyphs not assigned to a class fall into class 0". (OpenType spec) + return 0; +} + +// Define to STBTT_assert(x) if you want to break on unimplemented formats. +#define STBTT_GPOS_TODO_assert(x) + +static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + stbtt_uint16 lookupListOffset; + stbtt_uint8 *lookupList; + stbtt_uint16 lookupCount; + stbtt_uint8 *data; + stbtt_int32 i, sti; + + if (!info->gpos) return 0; + + data = info->data + info->gpos; + + if (ttUSHORT(data+0) != 1) return 0; // Major version 1 + if (ttUSHORT(data+2) != 0) return 0; // Minor version 0 + + lookupListOffset = ttUSHORT(data+8); + lookupList = data + lookupListOffset; + lookupCount = ttUSHORT(lookupList); + + for (i=0; i= pairSetCount) return 0; + + needle=glyph2; + r=pairValueCount-1; + l=0; + + // Binary search. + while (l <= r) { + stbtt_uint16 secondGlyph; + stbtt_uint8 *pairValue; + m = (l + r) >> 1; + pairValue = pairValueArray + (2 + valueRecordPairSizeInBytes) * m; + secondGlyph = ttUSHORT(pairValue); + straw = secondGlyph; + if (needle < straw) + r = m - 1; + else if (needle > straw) + l = m + 1; + else { + stbtt_int16 xAdvance = ttSHORT(pairValue + 2); + return xAdvance; + } + } + } else + return 0; + break; + } + + case 2: { + stbtt_uint16 valueFormat1 = ttUSHORT(table + 4); + stbtt_uint16 valueFormat2 = ttUSHORT(table + 6); + if (valueFormat1 == 4 && valueFormat2 == 0) { // Support more formats? + stbtt_uint16 classDef1Offset = ttUSHORT(table + 8); + stbtt_uint16 classDef2Offset = ttUSHORT(table + 10); + int glyph1class = stbtt__GetGlyphClass(table + classDef1Offset, glyph1); + int glyph2class = stbtt__GetGlyphClass(table + classDef2Offset, glyph2); + + stbtt_uint16 class1Count = ttUSHORT(table + 12); + stbtt_uint16 class2Count = ttUSHORT(table + 14); + stbtt_uint8 *class1Records, *class2Records; + stbtt_int16 xAdvance; + + if (glyph1class < 0 || glyph1class >= class1Count) return 0; // malformed + if (glyph2class < 0 || glyph2class >= class2Count) return 0; // malformed + + class1Records = table + 16; + class2Records = class1Records + 2 * (glyph1class * class2Count); + xAdvance = ttSHORT(class2Records + 2 * glyph2class); + return xAdvance; + } else + return 0; + break; + } + + default: + return 0; // Unsupported position format + } + } + } + + return 0; +} + +STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int g1, int g2) +{ + int xAdvance = 0; + + if (info->gpos) + xAdvance += stbtt__GetGlyphGPOSInfoAdvance(info, g1, g2); + else if (info->kern) + xAdvance += stbtt__GetGlyphKernInfoAdvance(info, g1, g2); + + return xAdvance; +} + +STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) +{ + if (!info->kern && !info->gpos) // if no kerning table, don't waste time looking up both codepoint->glyphs + return 0; + return stbtt_GetGlyphKernAdvance(info, stbtt_FindGlyphIndex(info,ch1), stbtt_FindGlyphIndex(info,ch2)); +} + +STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) +{ + stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); +} + +STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) +{ + if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); + if (descent) *descent = ttSHORT(info->data+info->hhea + 6); + if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); +} + +STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap) +{ + int tab = stbtt__find_table(info->data, info->fontstart, "OS/2"); + if (!tab) + return 0; + if (typoAscent ) *typoAscent = ttSHORT(info->data+tab + 68); + if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70); + if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72); + return 1; +} + +STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int *x0, int *y0, int *x1, int *y1) +{ + *x0 = ttSHORT(info->data + info->head + 36); + *y0 = ttSHORT(info->data + info->head + 38); + *x1 = ttSHORT(info->data + info->head + 40); + *y1 = ttSHORT(info->data + info->head + 42); +} + +STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) +{ + int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); + return (float) height / fheight; +} + +STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *info, float pixels) +{ + int unitsPerEm = ttUSHORT(info->data + info->head + 18); + return pixels / unitsPerEm; +} + +STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) +{ + STBTT_free(v, info->userdata); +} + +STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl) +{ + int i; + stbtt_uint8 *data = info->data; + stbtt_uint8 *svg_doc_list = data + stbtt__get_svg((stbtt_fontinfo *) info); + + int numEntries = ttUSHORT(svg_doc_list); + stbtt_uint8 *svg_docs = svg_doc_list + 2; + + for(i=0; i= ttUSHORT(svg_doc)) && (gl <= ttUSHORT(svg_doc + 2))) + return svg_doc; + } + return 0; +} + +STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, const char **svg) +{ + stbtt_uint8 *data = info->data; + stbtt_uint8 *svg_doc; + + if (info->svg == 0) + return 0; + + svg_doc = stbtt_FindSVGDoc(info, gl); + if (svg_doc != NULL) { + *svg = (char *) data + info->svg + ttULONG(svg_doc + 4); + return ttULONG(svg_doc + 8); + } else { + return 0; + } +} + +STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unicode_codepoint, const char **svg) +{ + return stbtt_GetGlyphSVG(info, stbtt_FindGlyphIndex(info, unicode_codepoint), svg); +} + +////////////////////////////////////////////////////////////////////////////// +// +// antialiasing software rasterizer +// + +STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning + if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) { + // e.g. space character + if (ix0) *ix0 = 0; + if (iy0) *iy0 = 0; + if (ix1) *ix1 = 0; + if (iy1) *iy1 = 0; + } else { + // move to integral bboxes (treating pixels as little squares, what pixels get touched)? + if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x); + if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y); + if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x); + if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y); + } +} + +STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBoxSubpixel(font, glyph, scale_x, scale_y,0.0f,0.0f, ix0, iy0, ix1, iy1); +} + +STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBoxSubpixel(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y,shift_x,shift_y, ix0,iy0,ix1,iy1); +} + +STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetCodepointBitmapBoxSubpixel(font, codepoint, scale_x, scale_y,0.0f,0.0f, ix0,iy0,ix1,iy1); +} + +////////////////////////////////////////////////////////////////////////////// +// +// Rasterizer + +typedef struct stbtt__hheap_chunk +{ + struct stbtt__hheap_chunk *next; +} stbtt__hheap_chunk; + +typedef struct stbtt__hheap +{ + struct stbtt__hheap_chunk *head; + void *first_free; + int num_remaining_in_head_chunk; +} stbtt__hheap; + +static void *stbtt__hheap_alloc(stbtt__hheap *hh, size_t size, void *userdata) +{ + if (hh->first_free) { + void *p = hh->first_free; + hh->first_free = * (void **) p; + return p; + } else { + if (hh->num_remaining_in_head_chunk == 0) { + int count = (size < 32 ? 2000 : size < 128 ? 800 : 100); + stbtt__hheap_chunk *c = (stbtt__hheap_chunk *) STBTT_malloc(sizeof(stbtt__hheap_chunk) + size * count, userdata); + if (c == NULL) + return NULL; + c->next = hh->head; + hh->head = c; + hh->num_remaining_in_head_chunk = count; + } + --hh->num_remaining_in_head_chunk; + return (char *) (hh->head) + sizeof(stbtt__hheap_chunk) + size * hh->num_remaining_in_head_chunk; + } +} + +static void stbtt__hheap_free(stbtt__hheap *hh, void *p) +{ + *(void **) p = hh->first_free; + hh->first_free = p; +} + +static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata) +{ + stbtt__hheap_chunk *c = hh->head; + while (c) { + stbtt__hheap_chunk *n = c->next; + STBTT_free(c, userdata); + c = n; + } +} + +typedef struct stbtt__edge { + float x0,y0, x1,y1; + int invert; +} stbtt__edge; + + +typedef struct stbtt__active_edge +{ + struct stbtt__active_edge *next; + #if STBTT_RASTERIZER_VERSION==1 + int x,dx; + float ey; + int direction; + #elif STBTT_RASTERIZER_VERSION==2 + float fx,fdx,fdy; + float direction; + float sy; + float ey; + #else + #error "Unrecognized value of STBTT_RASTERIZER_VERSION" + #endif +} stbtt__active_edge; + +#if STBTT_RASTERIZER_VERSION == 1 +#define STBTT_FIXSHIFT 10 +#define STBTT_FIX (1 << STBTT_FIXSHIFT) +#define STBTT_FIXMASK (STBTT_FIX-1) + +static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(z != NULL); + if (!z) return z; + + // round dx down to avoid overshooting + if (dxdy < 0) + z->dx = -STBTT_ifloor(STBTT_FIX * -dxdy); + else + z->dx = STBTT_ifloor(STBTT_FIX * dxdy); + + z->x = STBTT_ifloor(STBTT_FIX * e->x0 + z->dx * (start_point - e->y0)); // use z->dx so when we offset later it's by the same amount + z->x -= off_x * STBTT_FIX; + + z->ey = e->y1; + z->next = 0; + z->direction = e->invert ? 1 : -1; + return z; +} +#elif STBTT_RASTERIZER_VERSION == 2 +static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__edge *e, int off_x, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) stbtt__hheap_alloc(hh, sizeof(*z), userdata); + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(z != NULL); + //STBTT_assert(e->y0 <= start_point); + if (!z) return z; + z->fdx = dxdy; + z->fdy = dxdy != 0.0f ? (1.0f/dxdy) : 0.0f; + z->fx = e->x0 + dxdy * (start_point - e->y0); + z->fx -= off_x; + z->direction = e->invert ? 1.0f : -1.0f; + z->sy = e->y0; + z->ey = e->y1; + z->next = 0; + return z; +} +#else +#error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + +#if STBTT_RASTERIZER_VERSION == 1 +// note: this routine clips fills that extend off the edges... ideally this +// wouldn't happen, but it could happen if the truetype glyph bounding boxes +// are wrong, or if the user supplies a too-small bitmap +static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) +{ + // non-zero winding fill + int x0=0, w=0; + + while (e) { + if (w == 0) { + // if we're currently at zero, we need to record the edge start point + x0 = e->x; w += e->direction; + } else { + int x1 = e->x; w += e->direction; + // if we went to zero, we need to draw + if (w == 0) { + int i = x0 >> STBTT_FIXSHIFT; + int j = x1 >> STBTT_FIXSHIFT; + + if (i < len && j >= 0) { + if (i == j) { + // x0,x1 are the same pixel, so compute combined coverage + scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> STBTT_FIXSHIFT); + } else { + if (i >= 0) // add antialiasing for x0 + scanline[i] = scanline[i] + (stbtt_uint8) (((STBTT_FIX - (x0 & STBTT_FIXMASK)) * max_weight) >> STBTT_FIXSHIFT); + else + i = -1; // clip + + if (j < len) // add antialiasing for x1 + scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & STBTT_FIXMASK) * max_weight) >> STBTT_FIXSHIFT); + else + j = len; // clip + + for (++i; i < j; ++i) // fill pixels between x0 and x1 + scanline[i] = scanline[i] + (stbtt_uint8) max_weight; + } + } + } + } + + e = e->next; + } +} + +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0; + int max_weight = (255 / vsubsample); // weight per vertical scanline + int s; // vertical subsample index + unsigned char scanline_data[512], *scanline; + + if (result->w > 512) + scanline = (unsigned char *) STBTT_malloc(result->w, userdata); + else + scanline = scanline_data; + + y = off_y * vsubsample; + e[n].y0 = (off_y + result->h) * (float) vsubsample + 1; + + while (j < result->h) { + STBTT_memset(scanline, 0, result->w); + for (s=0; s < vsubsample; ++s) { + // find center of pixel for this scanline + float scan_y = y + 0.5f; + stbtt__active_edge **step = &active; + + // update all active edges; + // remove all active edges that terminate before the center of this scanline + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y) { + *step = z->next; // delete from list + STBTT_assert(z->direction); + z->direction = 0; + stbtt__hheap_free(&hh, z); + } else { + z->x += z->dx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + } + + // resort the list if needed + for(;;) { + int changed=0; + step = &active; + while (*step && (*step)->next) { + if ((*step)->x > (*step)->next->x) { + stbtt__active_edge *t = *step; + stbtt__active_edge *q = t->next; + + t->next = q->next; + q->next = t; + *step = q; + changed = 1; + } + step = &(*step)->next; + } + if (!changed) break; + } + + // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline + while (e->y0 <= scan_y) { + if (e->y1 > scan_y) { + stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y, userdata); + if (z != NULL) { + // find insertion point + if (active == NULL) + active = z; + else if (z->x < active->x) { + // insert at front + z->next = active; + active = z; + } else { + // find thing to insert AFTER + stbtt__active_edge *p = active; + while (p->next && p->next->x < z->x) + p = p->next; + // at this point, p->next->x is NOT < z->x + z->next = p->next; + p->next = z; + } + } + } + ++e; + } + + // now process all active edges in XOR fashion + if (active) + stbtt__fill_active_edges(scanline, result->w, active, max_weight); + + ++y; + } + STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); + ++j; + } + + stbtt__hheap_cleanup(&hh, userdata); + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} + +#elif STBTT_RASTERIZER_VERSION == 2 + +// the edge passed in here does not cross the vertical line at x or the vertical line at x+1 +// (i.e. it has already been clipped to those) +static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__active_edge *e, float x0, float y0, float x1, float y1) +{ + if (y0 == y1) return; + STBTT_assert(y0 < y1); + STBTT_assert(e->sy <= e->ey); + if (y0 > e->ey) return; + if (y1 < e->sy) return; + if (y0 < e->sy) { + x0 += (x1-x0) * (e->sy - y0) / (y1-y0); + y0 = e->sy; + } + if (y1 > e->ey) { + x1 += (x1-x0) * (e->ey - y1) / (y1-y0); + y1 = e->ey; + } + + if (x0 == x) + STBTT_assert(x1 <= x+1); + else if (x0 == x+1) + STBTT_assert(x1 >= x); + else if (x0 <= x) + STBTT_assert(x1 <= x); + else if (x0 >= x+1) + STBTT_assert(x1 >= x+1); + else + STBTT_assert(x1 >= x && x1 <= x+1); + + if (x0 <= x && x1 <= x) + scanline[x] += e->direction * (y1-y0); + else if (x0 >= x+1 && x1 >= x+1) + ; + else { + STBTT_assert(x0 >= x && x0 <= x+1 && x1 >= x && x1 <= x+1); + scanline[x] += e->direction * (y1-y0) * (1-((x0-x)+(x1-x))/2); // coverage = 1 - average x position + } +} + +static float stbtt__sized_trapezoid_area(float height, float top_width, float bottom_width) +{ + STBTT_assert(top_width >= 0); + STBTT_assert(bottom_width >= 0); + return (top_width + bottom_width) / 2.0f * height; +} + +static float stbtt__position_trapezoid_area(float height, float tx0, float tx1, float bx0, float bx1) +{ + return stbtt__sized_trapezoid_area(height, tx1 - tx0, bx1 - bx0); +} + +static float stbtt__sized_triangle_area(float height, float width) +{ + return height * width / 2; +} + +static void stbtt__fill_active_edges_new(float *scanline, float *scanline_fill, int len, stbtt__active_edge *e, float y_top) +{ + float y_bottom = y_top+1; + + while (e) { + // brute force every pixel + + // compute intersection points with top & bottom + STBTT_assert(e->ey >= y_top); + + if (e->fdx == 0) { + float x0 = e->fx; + if (x0 < len) { + if (x0 >= 0) { + stbtt__handle_clipped_edge(scanline,(int) x0,e, x0,y_top, x0,y_bottom); + stbtt__handle_clipped_edge(scanline_fill-1,(int) x0+1,e, x0,y_top, x0,y_bottom); + } else { + stbtt__handle_clipped_edge(scanline_fill-1,0,e, x0,y_top, x0,y_bottom); + } + } + } else { + float x0 = e->fx; + float dx = e->fdx; + float xb = x0 + dx; + float x_top, x_bottom; + float sy0,sy1; + float dy = e->fdy; + STBTT_assert(e->sy <= y_bottom && e->ey >= y_top); + + // compute endpoints of line segment clipped to this scanline (if the + // line segment starts on this scanline. x0 is the intersection of the + // line with y_top, but that may be off the line segment. + if (e->sy > y_top) { + x_top = x0 + dx * (e->sy - y_top); + sy0 = e->sy; + } else { + x_top = x0; + sy0 = y_top; + } + if (e->ey < y_bottom) { + x_bottom = x0 + dx * (e->ey - y_top); + sy1 = e->ey; + } else { + x_bottom = xb; + sy1 = y_bottom; + } + + if (x_top >= 0 && x_bottom >= 0 && x_top < len && x_bottom < len) { + // from here on, we don't have to range check x values + + if ((int) x_top == (int) x_bottom) { + float height; + // simple case, only spans one pixel + int x = (int) x_top; + height = (sy1 - sy0) * e->direction; + STBTT_assert(x >= 0 && x < len); + scanline[x] += stbtt__position_trapezoid_area(height, x_top, x+1.0f, x_bottom, x+1.0f); + scanline_fill[x] += height; // everything right of this pixel is filled + } else { + int x,x1,x2; + float y_crossing, y_final, step, sign, area; + // covers 2+ pixels + if (x_top > x_bottom) { + // flip scanline vertically; signed area is the same + float t; + sy0 = y_bottom - (sy0 - y_top); + sy1 = y_bottom - (sy1 - y_top); + t = sy0, sy0 = sy1, sy1 = t; + t = x_bottom, x_bottom = x_top, x_top = t; + dx = -dx; + dy = -dy; + t = x0, x0 = xb, xb = t; + } + STBTT_assert(dy >= 0); + STBTT_assert(dx >= 0); + + x1 = (int) x_top; + x2 = (int) x_bottom; + // compute intersection with y axis at x1+1 + y_crossing = y_top + dy * (x1+1 - x0); + + // compute intersection with y axis at x2 + y_final = y_top + dy * (x2 - x0); + + // x1 x_top x2 x_bottom + // y_top +------|-----+------------+------------+--------|---+------------+ + // | | | | | | + // | | | | | | + // sy0 | Txxxxx|............|............|............|............| + // y_crossing | *xxxxx.......|............|............|............| + // | | xxxxx..|............|............|............| + // | | /- xx*xxxx........|............|............| + // | | dy < | xxxxxx..|............|............| + // y_final | | \- | xx*xxx.........|............| + // sy1 | | | | xxxxxB...|............| + // | | | | | | + // | | | | | | + // y_bottom +------------+------------+------------+------------+------------+ + // + // goal is to measure the area covered by '.' in each pixel + + // if x2 is right at the right edge of x1, y_crossing can blow up, github #1057 + // @TODO: maybe test against sy1 rather than y_bottom? + if (y_crossing > y_bottom) + y_crossing = y_bottom; + + sign = e->direction; + + // area of the rectangle covered from sy0..y_crossing + area = sign * (y_crossing-sy0); + + // area of the triangle (x_top,sy0), (x1+1,sy0), (x1+1,y_crossing) + scanline[x1] += stbtt__sized_triangle_area(area, x1+1 - x_top); + + // check if final y_crossing is blown up; no test case for this + if (y_final > y_bottom) { + y_final = y_bottom; + dy = (y_final - y_crossing ) / (x2 - (x1+1)); // if denom=0, y_final = y_crossing, so y_final <= y_bottom + } + + // in second pixel, area covered by line segment found in first pixel + // is always a rectangle 1 wide * the height of that line segment; this + // is exactly what the variable 'area' stores. it also gets a contribution + // from the line segment within it. the THIRD pixel will get the first + // pixel's rectangle contribution, the second pixel's rectangle contribution, + // and its own contribution. the 'own contribution' is the same in every pixel except + // the leftmost and rightmost, a trapezoid that slides down in each pixel. + // the second pixel's contribution to the third pixel will be the + // rectangle 1 wide times the height change in the second pixel, which is dy. + + step = sign * dy * 1; // dy is dy/dx, change in y for every 1 change in x, + // which multiplied by 1-pixel-width is how much pixel area changes for each step in x + // so the area advances by 'step' every time + + for (x = x1+1; x < x2; ++x) { + scanline[x] += area + step/2; // area of trapezoid is 1*step/2 + area += step; + } + STBTT_assert(STBTT_fabs(area) <= 1.01f); // accumulated error from area += step unless we round step down + STBTT_assert(sy1 > y_final-0.01f); + + // area covered in the last pixel is the rectangle from all the pixels to the left, + // plus the trapezoid filled by the line segment in this pixel all the way to the right edge + scanline[x2] += area + sign * stbtt__position_trapezoid_area(sy1-y_final, (float) x2, x2+1.0f, x_bottom, x2+1.0f); + + // the rest of the line is filled based on the total height of the line segment in this pixel + scanline_fill[x2] += sign * (sy1-sy0); + } + } else { + // if edge goes outside of box we're drawing, we require + // clipping logic. since this does not match the intended use + // of this library, we use a different, very slow brute + // force implementation + // note though that this does happen some of the time because + // x_top and x_bottom can be extrapolated at the top & bottom of + // the shape and actually lie outside the bounding box + int x; + for (x=0; x < len; ++x) { + // cases: + // + // there can be up to two intersections with the pixel. any intersection + // with left or right edges can be handled by splitting into two (or three) + // regions. intersections with top & bottom do not necessitate case-wise logic. + // + // the old way of doing this found the intersections with the left & right edges, + // then used some simple logic to produce up to three segments in sorted order + // from top-to-bottom. however, this had a problem: if an x edge was epsilon + // across the x border, then the corresponding y position might not be distinct + // from the other y segment, and it might ignored as an empty segment. to avoid + // that, we need to explicitly produce segments based on x positions. + + // rename variables to clearly-defined pairs + float y0 = y_top; + float x1 = (float) (x); + float x2 = (float) (x+1); + float x3 = xb; + float y3 = y_bottom; + + // x = e->x + e->dx * (y-y_top) + // (y-y_top) = (x - e->x) / e->dx + // y = (x - e->x) / e->dx + y_top + float y1 = (x - x0) / dx + y_top; + float y2 = (x+1 - x0) / dx + y_top; + + if (x0 < x1 && x3 > x2) { // three segments descending down-right + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else if (x3 < x1 && x0 > x2) { // three segments descending down-left + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x0 < x1 && x3 > x1) { // two segments across x, down-right + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x3 < x1 && x0 > x1) { // two segments across x, down-left + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x1,y1); + stbtt__handle_clipped_edge(scanline,x,e, x1,y1, x3,y3); + } else if (x0 < x2 && x3 > x2) { // two segments across x+1, down-right + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else if (x3 < x2 && x0 > x2) { // two segments across x+1, down-left + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x2,y2); + stbtt__handle_clipped_edge(scanline,x,e, x2,y2, x3,y3); + } else { // one segment + stbtt__handle_clipped_edge(scanline,x,e, x0,y0, x3,y3); + } + } + } + } + e = e->next; + } +} + +// directly AA rasterize edges w/o supersampling +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + stbtt__hheap hh = { 0, 0, 0 }; + stbtt__active_edge *active = NULL; + int y,j=0, i; + float scanline_data[129], *scanline, *scanline2; + + STBTT__NOTUSED(vsubsample); + + if (result->w > 64) + scanline = (float *) STBTT_malloc((result->w*2+1) * sizeof(float), userdata); + else + scanline = scanline_data; + + scanline2 = scanline + result->w; + + y = off_y; + e[n].y0 = (float) (off_y + result->h) + 1; + + while (j < result->h) { + // find center of pixel for this scanline + float scan_y_top = y + 0.0f; + float scan_y_bottom = y + 1.0f; + stbtt__active_edge **step = &active; + + STBTT_memset(scanline , 0, result->w*sizeof(scanline[0])); + STBTT_memset(scanline2, 0, (result->w+1)*sizeof(scanline[0])); + + // update all active edges; + // remove all active edges that terminate before the top of this scanline + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y_top) { + *step = z->next; // delete from list + STBTT_assert(z->direction); + z->direction = 0; + stbtt__hheap_free(&hh, z); + } else { + step = &((*step)->next); // advance through list + } + } + + // insert all edges that start before the bottom of this scanline + while (e->y0 <= scan_y_bottom) { + if (e->y0 != e->y1) { + stbtt__active_edge *z = stbtt__new_active(&hh, e, off_x, scan_y_top, userdata); + if (z != NULL) { + if (j == 0 && off_y != 0) { + if (z->ey < scan_y_top) { + // this can happen due to subpixel positioning and some kind of fp rounding error i think + z->ey = scan_y_top; + } + } + STBTT_assert(z->ey >= scan_y_top); // if we get really unlucky a tiny bit of an edge can be out of bounds + // insert at front + z->next = active; + active = z; + } + } + ++e; + } + + // now process all active edges + if (active) + stbtt__fill_active_edges_new(scanline, scanline2+1, result->w, active, scan_y_top); + + { + float sum = 0; + for (i=0; i < result->w; ++i) { + float k; + int m; + sum += scanline2[i]; + k = scanline[i] + sum; + k = (float) STBTT_fabs(k)*255 + 0.5f; + m = (int) k; + if (m > 255) m = 255; + result->pixels[j*result->stride + i] = (unsigned char) m; + } + } + // advance all the edges + step = &active; + while (*step) { + stbtt__active_edge *z = *step; + z->fx += z->fdx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + + ++y; + ++j; + } + + stbtt__hheap_cleanup(&hh, userdata); + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} +#else +#error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + +#define STBTT__COMPARE(a,b) ((a)->y0 < (b)->y0) + +static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n) +{ + int i,j; + for (i=1; i < n; ++i) { + stbtt__edge t = p[i], *a = &t; + j = i; + while (j > 0) { + stbtt__edge *b = &p[j-1]; + int c = STBTT__COMPARE(a,b); + if (!c) break; + p[j] = p[j-1]; + --j; + } + if (i != j) + p[j] = t; + } +} + +static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n) +{ + /* threshold for transitioning to insertion sort */ + while (n > 12) { + stbtt__edge t; + int c01,c12,c,m,i,j; + + /* compute median of three */ + m = n >> 1; + c01 = STBTT__COMPARE(&p[0],&p[m]); + c12 = STBTT__COMPARE(&p[m],&p[n-1]); + /* if 0 >= mid >= end, or 0 < mid < end, then use mid */ + if (c01 != c12) { + /* otherwise, we'll need to swap something else to middle */ + int z; + c = STBTT__COMPARE(&p[0],&p[n-1]); + /* 0>mid && midn => n; 0 0 */ + /* 0n: 0>n => 0; 0 n */ + z = (c == c12) ? 0 : n-1; + t = p[z]; + p[z] = p[m]; + p[m] = t; + } + /* now p[m] is the median-of-three */ + /* swap it to the beginning so it won't move around */ + t = p[0]; + p[0] = p[m]; + p[m] = t; + + /* partition loop */ + i=1; + j=n-1; + for(;;) { + /* handling of equality is crucial here */ + /* for sentinels & efficiency with duplicates */ + for (;;++i) { + if (!STBTT__COMPARE(&p[i], &p[0])) break; + } + for (;;--j) { + if (!STBTT__COMPARE(&p[0], &p[j])) break; + } + /* make sure we haven't crossed */ + if (i >= j) break; + t = p[i]; + p[i] = p[j]; + p[j] = t; + + ++i; + --j; + } + /* recurse on smaller side, iterate on larger */ + if (j < (n-i)) { + stbtt__sort_edges_quicksort(p,j); + p = p+i; + n = n-i; + } else { + stbtt__sort_edges_quicksort(p+i, n-i); + n = j; + } + } +} + +static void stbtt__sort_edges(stbtt__edge *p, int n) +{ + stbtt__sort_edges_quicksort(p, n); + stbtt__sort_edges_ins_sort(p, n); +} + +typedef struct +{ + float x,y; +} stbtt__point; + +static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, float shift_x, float shift_y, int off_x, int off_y, int invert, void *userdata) +{ + float y_scale_inv = invert ? -scale_y : scale_y; + stbtt__edge *e; + int n,i,j,k,m; +#if STBTT_RASTERIZER_VERSION == 1 + int vsubsample = result->h < 8 ? 15 : 5; +#elif STBTT_RASTERIZER_VERSION == 2 + int vsubsample = 1; +#else + #error "Unrecognized value of STBTT_RASTERIZER_VERSION" +#endif + // vsubsample should divide 255 evenly; otherwise we won't reach full opacity + + // now we have to blow out the windings into explicit edge lists + n = 0; + for (i=0; i < windings; ++i) + n += wcount[i]; + + e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel + if (e == 0) return; + n = 0; + + m=0; + for (i=0; i < windings; ++i) { + stbtt__point *p = pts + m; + m += wcount[i]; + j = wcount[i]-1; + for (k=0; k < wcount[i]; j=k++) { + int a=k,b=j; + // skip the edge if horizontal + if (p[j].y == p[k].y) + continue; + // add edge from j to k to the list + e[n].invert = 0; + if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { + e[n].invert = 1; + a=j,b=k; + } + e[n].x0 = p[a].x * scale_x + shift_x; + e[n].y0 = (p[a].y * y_scale_inv + shift_y) * vsubsample; + e[n].x1 = p[b].x * scale_x + shift_x; + e[n].y1 = (p[b].y * y_scale_inv + shift_y) * vsubsample; + ++n; + } + } + + // now sort the edges by their highest point (should snap to integer, and then by x) + //STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); + stbtt__sort_edges(e, n); + + // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule + stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); + + STBTT_free(e, userdata); +} + +static void stbtt__add_point(stbtt__point *points, int n, float x, float y) +{ + if (!points) return; // during first pass, it's unallocated + points[n].x = x; + points[n].y = y; +} + +// tessellate until threshold p is happy... @TODO warped to compensate for non-linear stretching +static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) +{ + // midpoint + float mx = (x0 + 2*x1 + x2)/4; + float my = (y0 + 2*y1 + y2)/4; + // versus directly drawn line + float dx = (x0+x2)/2 - mx; + float dy = (y0+y2)/2 - my; + if (n > 16) // 65536 segments on one curve better be enough! + return 1; + if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA + stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x2,y2); + *num_points = *num_points+1; + } + return 1; +} + +static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3, float objspace_flatness_squared, int n) +{ + // @TODO this "flatness" calculation is just made-up nonsense that seems to work well enough + float dx0 = x1-x0; + float dy0 = y1-y0; + float dx1 = x2-x1; + float dy1 = y2-y1; + float dx2 = x3-x2; + float dy2 = y3-y2; + float dx = x3-x0; + float dy = y3-y0; + float longlen = (float) (STBTT_sqrt(dx0*dx0+dy0*dy0)+STBTT_sqrt(dx1*dx1+dy1*dy1)+STBTT_sqrt(dx2*dx2+dy2*dy2)); + float shortlen = (float) STBTT_sqrt(dx*dx+dy*dy); + float flatness_squared = longlen*longlen-shortlen*shortlen; + + if (n > 16) // 65536 segments on one curve better be enough! + return; + + if (flatness_squared > objspace_flatness_squared) { + float x01 = (x0+x1)/2; + float y01 = (y0+y1)/2; + float x12 = (x1+x2)/2; + float y12 = (y1+y2)/2; + float x23 = (x2+x3)/2; + float y23 = (y2+y3)/2; + + float xa = (x01+x12)/2; + float ya = (y01+y12)/2; + float xb = (x12+x23)/2; + float yb = (y12+y23)/2; + + float mx = (xa+xb)/2; + float my = (ya+yb)/2; + + stbtt__tesselate_cubic(points, num_points, x0,y0, x01,y01, xa,ya, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_cubic(points, num_points, mx,my, xb,yb, x23,y23, x3,y3, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x3,y3); + *num_points = *num_points+1; + } +} + +// returns number of contours +static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) +{ + stbtt__point *points=0; + int num_points=0; + + float objspace_flatness_squared = objspace_flatness * objspace_flatness; + int i,n=0,start=0, pass; + + // count how many "moves" there are to get the contour count + for (i=0; i < num_verts; ++i) + if (vertices[i].type == STBTT_vmove) + ++n; + + *num_contours = n; + if (n == 0) return 0; + + *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); + + if (*contour_lengths == 0) { + *num_contours = 0; + return 0; + } + + // make two passes through the points so we don't need to realloc + for (pass=0; pass < 2; ++pass) { + float x=0,y=0; + if (pass == 1) { + points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); + if (points == NULL) goto error; + } + num_points = 0; + n= -1; + for (i=0; i < num_verts; ++i) { + switch (vertices[i].type) { + case STBTT_vmove: + // start the next contour + if (n >= 0) + (*contour_lengths)[n] = num_points - start; + ++n; + start = num_points; + + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x,y); + break; + case STBTT_vline: + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x, y); + break; + case STBTT_vcurve: + stbtt__tesselate_curve(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + case STBTT_vcubic: + stbtt__tesselate_cubic(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].cx1, vertices[i].cy1, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + } + } + (*contour_lengths)[n] = num_points - start; + } + + return points; +error: + STBTT_free(points, userdata); + STBTT_free(*contour_lengths, userdata); + *contour_lengths = 0; + *num_contours = 0; + return NULL; +} + +STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, float shift_x, float shift_y, int x_off, int y_off, int invert, void *userdata) +{ + float scale = scale_x > scale_y ? scale_y : scale_x; + int winding_count = 0; + int *winding_lengths = NULL; + stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); + if (windings) { + stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, shift_x, shift_y, x_off, y_off, invert, userdata); + STBTT_free(winding_lengths, userdata); + STBTT_free(windings, userdata); + } +} + +STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) +{ + STBTT_free(bitmap, userdata); +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + int ix0,iy0,ix1,iy1; + stbtt__bitmap gbm; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + + if (scale_x == 0) scale_x = scale_y; + if (scale_y == 0) { + if (scale_x == 0) { + STBTT_free(vertices, info->userdata); + return NULL; + } + scale_y = scale_x; + } + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,&ix1,&iy1); + + // now we get the size + gbm.w = (ix1 - ix0); + gbm.h = (iy1 - iy0); + gbm.pixels = NULL; // in case we error + + if (width ) *width = gbm.w; + if (height) *height = gbm.h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + if (gbm.w && gbm.h) { + gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); + if (gbm.pixels) { + gbm.stride = gbm.w; + + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0, iy0, 1, info->userdata); + } + } + STBTT_free(vertices, info->userdata); + return gbm.pixels; +} + +STBTT_DEF unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y, 0.0f, 0.0f, glyph, width, height, xoff, yoff); +} + +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int glyph) +{ + int ix0,iy0; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + stbtt__bitmap gbm; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale_x, scale_y, shift_x, shift_y, &ix0,&iy0,0,0); + gbm.pixels = output; + gbm.w = out_w; + gbm.h = out_h; + gbm.stride = out_stride; + + if (gbm.w && gbm.h) + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, shift_x, shift_y, ix0,iy0, 1, info->userdata); + + STBTT_free(vertices, info->userdata); +} + +STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph) +{ + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, glyph); +} + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmapSubpixel(const stbtt_fontinfo *info, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmapSubpixel(info, scale_x, scale_y,shift_x,shift_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); +} + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int oversample_x, int oversample_y, float *sub_x, float *sub_y, int codepoint) +{ + stbtt_MakeGlyphBitmapSubpixelPrefilter(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, oversample_x, oversample_y, sub_x, sub_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int codepoint) +{ + stbtt_MakeGlyphBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, shift_x, shift_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +STBTT_DEF unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetCodepointBitmapSubpixel(info, scale_x, scale_y, 0.0f,0.0f, codepoint, width,height,xoff,yoff); +} + +STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint) +{ + stbtt_MakeCodepointBitmapSubpixel(info, output, out_w, out_h, out_stride, scale_x, scale_y, 0.0f,0.0f, codepoint); +} + +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-CRAPPY packing to keep source code small + +static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata) +{ + float scale; + int x,y,bottom_y, i; + stbtt_fontinfo f; + f.userdata = NULL; + if (!stbtt_InitFont(&f, data, offset)) + return -1; + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels + x=y=1; + bottom_y = 1; + + scale = stbtt_ScaleForPixelHeight(&f, pixel_height); + + for (i=0; i < num_chars; ++i) { + int advance, lsb, x0,y0,x1,y1,gw,gh; + int g = stbtt_FindGlyphIndex(&f, first_char + i); + stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); + stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); + gw = x1-x0; + gh = y1-y0; + if (x + gw + 1 >= pw) + y = bottom_y, x = 1; // advance to next row + if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row + return -i; + STBTT_assert(x+gw < pw); + STBTT_assert(y+gh < ph); + stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); + chardata[i].x0 = (stbtt_int16) x; + chardata[i].y0 = (stbtt_int16) y; + chardata[i].x1 = (stbtt_int16) (x + gw); + chardata[i].y1 = (stbtt_int16) (y + gh); + chardata[i].xadvance = scale * advance; + chardata[i].xoff = (float) x0; + chardata[i].yoff = (float) y0; + x = x + gw + 1; + if (y+gh+1 > bottom_y) + bottom_y = y+gh+1; + } + return bottom_y; +} + +STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) +{ + float d3d_bias = opengl_fillrule ? 0 : -0.5f; + float ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_bakedchar *b = chardata + char_index; + int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5f); + int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5f); + + q->x0 = round_x + d3d_bias; + q->y0 = round_y + d3d_bias; + q->x1 = round_x + b->x1 - b->x0 + d3d_bias; + q->y1 = round_y + b->y1 - b->y0 + d3d_bias; + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +////////////////////////////////////////////////////////////////////////////// +// +// rectangle packing replacement routines if you don't have stb_rect_pack.h +// + +#ifndef STB_RECT_PACK_VERSION + +typedef int stbrp_coord; + +//////////////////////////////////////////////////////////////////////////////////// +// // +// // +// COMPILER WARNING ?!?!? // +// // +// // +// if you get a compile warning due to these symbols being defined more than // +// once, move #include "stb_rect_pack.h" before #include "stb_truetype.h" // +// // +//////////////////////////////////////////////////////////////////////////////////// + +typedef struct +{ + int width,height; + int x,y,bottom_y; +} stbrp_context; + +typedef struct +{ + unsigned char x; +} stbrp_node; + +struct stbrp_rect +{ + stbrp_coord x,y; + int id,w,h,was_packed; +}; + +static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_node *nodes, int num_nodes) +{ + con->width = pw; + con->height = ph; + con->x = 0; + con->y = 0; + con->bottom_y = 0; + STBTT__NOTUSED(nodes); + STBTT__NOTUSED(num_nodes); +} + +static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int num_rects) +{ + int i; + for (i=0; i < num_rects; ++i) { + if (con->x + rects[i].w > con->width) { + con->x = 0; + con->y = con->bottom_y; + } + if (con->y + rects[i].h > con->height) + break; + rects[i].x = con->x; + rects[i].y = con->y; + rects[i].was_packed = 1; + con->x += rects[i].w; + if (con->y + rects[i].h > con->bottom_y) + con->bottom_y = con->y + rects[i].h; + } + for ( ; i < num_rects; ++i) + rects[i].was_packed = 0; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-AWESOME (tm Ryan Gordon) packing using stb_rect_pack.h. If +// stb_rect_pack.h isn't available, it uses the BakeFontBitmap strategy. + +STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context) +{ + stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context) ,alloc_context); + int num_nodes = pw - padding; + stbrp_node *nodes = (stbrp_node *) STBTT_malloc(sizeof(*nodes ) * num_nodes,alloc_context); + + if (context == NULL || nodes == NULL) { + if (context != NULL) STBTT_free(context, alloc_context); + if (nodes != NULL) STBTT_free(nodes , alloc_context); + return 0; + } + + spc->user_allocator_context = alloc_context; + spc->width = pw; + spc->height = ph; + spc->pixels = pixels; + spc->pack_info = context; + spc->nodes = nodes; + spc->padding = padding; + spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw; + spc->h_oversample = 1; + spc->v_oversample = 1; + spc->skip_missing = 0; + + stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes); + + if (pixels) + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels + + return 1; +} + +STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc) +{ + STBTT_free(spc->nodes , spc->user_allocator_context); + STBTT_free(spc->pack_info, spc->user_allocator_context); +} + +STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample) +{ + STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE); + STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE); + if (h_oversample <= STBTT_MAX_OVERSAMPLE) + spc->h_oversample = h_oversample; + if (v_oversample <= STBTT_MAX_OVERSAMPLE) + spc->v_oversample = v_oversample; +} + +STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *spc, int skip) +{ + spc->skip_missing = skip; +} + +#define STBTT__OVER_MASK (STBTT_MAX_OVERSAMPLE-1) + +static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) +{ + unsigned char buffer[STBTT_MAX_OVERSAMPLE]; + int safe_w = w - kernel_width; + int j; + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze + for (j=0; j < h; ++j) { + int i; + unsigned int total; + STBTT_memset(buffer, 0, kernel_width); + + total = 0; + + // make kernel_width a constant in common cases so compiler can optimize out the divide + switch (kernel_width) { + case 2: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 2); + } + break; + case 3: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 3); + } + break; + case 4: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 4); + } + break; + case 5: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / 5); + } + break; + default: + for (i=0; i <= safe_w; ++i) { + total += pixels[i] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i]; + pixels[i] = (unsigned char) (total / kernel_width); + } + break; + } + + for (; i < w; ++i) { + STBTT_assert(pixels[i] == 0); + total -= buffer[i & STBTT__OVER_MASK]; + pixels[i] = (unsigned char) (total / kernel_width); + } + + pixels += stride_in_bytes; + } +} + +static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_in_bytes, unsigned int kernel_width) +{ + unsigned char buffer[STBTT_MAX_OVERSAMPLE]; + int safe_h = h - kernel_width; + int j; + STBTT_memset(buffer, 0, STBTT_MAX_OVERSAMPLE); // suppress bogus warning from VS2013 -analyze + for (j=0; j < w; ++j) { + int i; + unsigned int total; + STBTT_memset(buffer, 0, kernel_width); + + total = 0; + + // make kernel_width a constant in common cases so compiler can optimize out the divide + switch (kernel_width) { + case 2: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 2); + } + break; + case 3: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 3); + } + break; + case 4: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 4); + } + break; + case 5: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / 5); + } + break; + default: + for (i=0; i <= safe_h; ++i) { + total += pixels[i*stride_in_bytes] - buffer[i & STBTT__OVER_MASK]; + buffer[(i+kernel_width) & STBTT__OVER_MASK] = pixels[i*stride_in_bytes]; + pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); + } + break; + } + + for (; i < h; ++i) { + STBTT_assert(pixels[i*stride_in_bytes] == 0); + total -= buffer[i & STBTT__OVER_MASK]; + pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width); + } + + pixels += 1; + } +} + +static float stbtt__oversample_shift(int oversample) +{ + if (!oversample) + return 0.0f; + + // The prefilter is a box filter of width "oversample", + // which shifts phase by (oversample - 1)/2 pixels in + // oversampled space. We want to shift in the opposite + // direction to counter this. + return (float)-(oversample - 1) / (2.0f * (float)oversample); +} + +// rects array must be big enough to accommodate all characters in the given ranges +STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) +{ + int i,j,k; + int missing_glyph_added = 0; + + k=0; + for (i=0; i < num_ranges; ++i) { + float fh = ranges[i].font_size; + float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + ranges[i].h_oversample = (unsigned char) spc->h_oversample; + ranges[i].v_oversample = (unsigned char) spc->v_oversample; + for (j=0; j < ranges[i].num_chars; ++j) { + int x0,y0,x1,y1; + int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; + int glyph = stbtt_FindGlyphIndex(info, codepoint); + if (glyph == 0 && (spc->skip_missing || missing_glyph_added)) { + rects[k].w = rects[k].h = 0; + } else { + stbtt_GetGlyphBitmapBoxSubpixel(info,glyph, + scale * spc->h_oversample, + scale * spc->v_oversample, + 0,0, + &x0,&y0,&x1,&y1); + rects[k].w = (stbrp_coord) (x1-x0 + spc->padding + spc->h_oversample-1); + rects[k].h = (stbrp_coord) (y1-y0 + spc->padding + spc->v_oversample-1); + if (glyph == 0) + missing_glyph_added = 1; + } + ++k; + } + } + + return k; +} + +STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, float shift_x, float shift_y, int prefilter_x, int prefilter_y, float *sub_x, float *sub_y, int glyph) +{ + stbtt_MakeGlyphBitmapSubpixel(info, + output, + out_w - (prefilter_x - 1), + out_h - (prefilter_y - 1), + out_stride, + scale_x, + scale_y, + shift_x, + shift_y, + glyph); + + if (prefilter_x > 1) + stbtt__h_prefilter(output, out_w, out_h, out_stride, prefilter_x); + + if (prefilter_y > 1) + stbtt__v_prefilter(output, out_w, out_h, out_stride, prefilter_y); + + *sub_x = stbtt__oversample_shift(prefilter_x); + *sub_y = stbtt__oversample_shift(prefilter_y); +} + +// rects array must be big enough to accommodate all characters in the given ranges +STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *spc, const stbtt_fontinfo *info, stbtt_pack_range *ranges, int num_ranges, stbrp_rect *rects) +{ + int i,j,k, missing_glyph = -1, return_value = 1; + + // save current values + int old_h_over = spc->h_oversample; + int old_v_over = spc->v_oversample; + + k = 0; + for (i=0; i < num_ranges; ++i) { + float fh = ranges[i].font_size; + float scale = fh > 0 ? stbtt_ScaleForPixelHeight(info, fh) : stbtt_ScaleForMappingEmToPixels(info, -fh); + float recip_h,recip_v,sub_x,sub_y; + spc->h_oversample = ranges[i].h_oversample; + spc->v_oversample = ranges[i].v_oversample; + recip_h = 1.0f / spc->h_oversample; + recip_v = 1.0f / spc->v_oversample; + sub_x = stbtt__oversample_shift(spc->h_oversample); + sub_y = stbtt__oversample_shift(spc->v_oversample); + for (j=0; j < ranges[i].num_chars; ++j) { + stbrp_rect *r = &rects[k]; + if (r->was_packed && r->w != 0 && r->h != 0) { + stbtt_packedchar *bc = &ranges[i].chardata_for_range[j]; + int advance, lsb, x0,y0,x1,y1; + int codepoint = ranges[i].array_of_unicode_codepoints == NULL ? ranges[i].first_unicode_codepoint_in_range + j : ranges[i].array_of_unicode_codepoints[j]; + int glyph = stbtt_FindGlyphIndex(info, codepoint); + stbrp_coord pad = (stbrp_coord) spc->padding; + + // pad on left and top + r->x += pad; + r->y += pad; + r->w -= pad; + r->h -= pad; + stbtt_GetGlyphHMetrics(info, glyph, &advance, &lsb); + stbtt_GetGlyphBitmapBox(info, glyph, + scale * spc->h_oversample, + scale * spc->v_oversample, + &x0,&y0,&x1,&y1); + stbtt_MakeGlyphBitmapSubpixel(info, + spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w - spc->h_oversample+1, + r->h - spc->v_oversample+1, + spc->stride_in_bytes, + scale * spc->h_oversample, + scale * spc->v_oversample, + 0,0, + glyph); + + if (spc->h_oversample > 1) + stbtt__h_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w, r->h, spc->stride_in_bytes, + spc->h_oversample); + + if (spc->v_oversample > 1) + stbtt__v_prefilter(spc->pixels + r->x + r->y*spc->stride_in_bytes, + r->w, r->h, spc->stride_in_bytes, + spc->v_oversample); + + bc->x0 = (stbtt_int16) r->x; + bc->y0 = (stbtt_int16) r->y; + bc->x1 = (stbtt_int16) (r->x + r->w); + bc->y1 = (stbtt_int16) (r->y + r->h); + bc->xadvance = scale * advance; + bc->xoff = (float) x0 * recip_h + sub_x; + bc->yoff = (float) y0 * recip_v + sub_y; + bc->xoff2 = (x0 + r->w) * recip_h + sub_x; + bc->yoff2 = (y0 + r->h) * recip_v + sub_y; + + if (glyph == 0) + missing_glyph = j; + } else if (spc->skip_missing) { + return_value = 0; + } else if (r->was_packed && r->w == 0 && r->h == 0 && missing_glyph >= 0) { + ranges[i].chardata_for_range[j] = ranges[i].chardata_for_range[missing_glyph]; + } else { + return_value = 0; // if any fail, report failure + } + + ++k; + } + } + + // restore original values + spc->h_oversample = old_h_over; + spc->v_oversample = old_v_over; + + return return_value; +} + +STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, stbrp_rect *rects, int num_rects) +{ + stbrp_pack_rects((stbrp_context *) spc->pack_info, rects, num_rects); +} + +STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, stbtt_pack_range *ranges, int num_ranges) +{ + stbtt_fontinfo info; + int i,j,n, return_value = 1; + //stbrp_context *context = (stbrp_context *) spc->pack_info; + stbrp_rect *rects; + + // flag all characters as NOT packed + for (i=0; i < num_ranges; ++i) + for (j=0; j < ranges[i].num_chars; ++j) + ranges[i].chardata_for_range[j].x0 = + ranges[i].chardata_for_range[j].y0 = + ranges[i].chardata_for_range[j].x1 = + ranges[i].chardata_for_range[j].y1 = 0; + + n = 0; + for (i=0; i < num_ranges; ++i) + n += ranges[i].num_chars; + + rects = (stbrp_rect *) STBTT_malloc(sizeof(*rects) * n, spc->user_allocator_context); + if (rects == NULL) + return 0; + + info.userdata = spc->user_allocator_context; + stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata,font_index)); + + n = stbtt_PackFontRangesGatherRects(spc, &info, ranges, num_ranges, rects); + + stbtt_PackFontRangesPackRects(spc, rects, n); + + return_value = stbtt_PackFontRangesRenderIntoRects(spc, &info, ranges, num_ranges, rects); + + STBTT_free(rects, spc->user_allocator_context); + return return_value; +} + +STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigned char *fontdata, int font_index, float font_size, + int first_unicode_codepoint_in_range, int num_chars_in_range, stbtt_packedchar *chardata_for_range) +{ + stbtt_pack_range range; + range.first_unicode_codepoint_in_range = first_unicode_codepoint_in_range; + range.array_of_unicode_codepoints = NULL; + range.num_chars = num_chars_in_range; + range.chardata_for_range = chardata_for_range; + range.font_size = font_size; + return stbtt_PackFontRanges(spc, fontdata, font_index, &range, 1); +} + +STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata, int index, float size, float *ascent, float *descent, float *lineGap) +{ + int i_ascent, i_descent, i_lineGap; + float scale; + stbtt_fontinfo info; + stbtt_InitFont(&info, fontdata, stbtt_GetFontOffsetForIndex(fontdata, index)); + scale = size > 0 ? stbtt_ScaleForPixelHeight(&info, size) : stbtt_ScaleForMappingEmToPixels(&info, -size); + stbtt_GetFontVMetrics(&info, &i_ascent, &i_descent, &i_lineGap); + *ascent = (float) i_ascent * scale; + *descent = (float) i_descent * scale; + *lineGap = (float) i_lineGap * scale; +} + +STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int align_to_integer) +{ + float ipw = 1.0f / pw, iph = 1.0f / ph; + const stbtt_packedchar *b = chardata + char_index; + + if (align_to_integer) { + float x = (float) STBTT_ifloor((*xpos + b->xoff) + 0.5f); + float y = (float) STBTT_ifloor((*ypos + b->yoff) + 0.5f); + q->x0 = x; + q->y0 = y; + q->x1 = x + b->xoff2 - b->xoff; + q->y1 = y + b->yoff2 - b->yoff; + } else { + q->x0 = *xpos + b->xoff; + q->y0 = *ypos + b->yoff; + q->x1 = *xpos + b->xoff2; + q->y1 = *ypos + b->yoff2; + } + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * iph; + q->s1 = b->x1 * ipw; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +////////////////////////////////////////////////////////////////////////////// +// +// sdf computation +// + +#define STBTT_min(a,b) ((a) < (b) ? (a) : (b)) +#define STBTT_max(a,b) ((a) < (b) ? (b) : (a)) + +static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], float q0[2], float q1[2], float q2[2], float hits[2][2]) +{ + float q0perp = q0[1]*ray[0] - q0[0]*ray[1]; + float q1perp = q1[1]*ray[0] - q1[0]*ray[1]; + float q2perp = q2[1]*ray[0] - q2[0]*ray[1]; + float roperp = orig[1]*ray[0] - orig[0]*ray[1]; + + float a = q0perp - 2*q1perp + q2perp; + float b = q1perp - q0perp; + float c = q0perp - roperp; + + float s0 = 0., s1 = 0.; + int num_s = 0; + + if (a != 0.0) { + float discr = b*b - a*c; + if (discr > 0.0) { + float rcpna = -1 / a; + float d = (float) STBTT_sqrt(discr); + s0 = (b+d) * rcpna; + s1 = (b-d) * rcpna; + if (s0 >= 0.0 && s0 <= 1.0) + num_s = 1; + if (d > 0.0 && s1 >= 0.0 && s1 <= 1.0) { + if (num_s == 0) s0 = s1; + ++num_s; + } + } + } else { + // 2*b*s + c = 0 + // s = -c / (2*b) + s0 = c / (-2 * b); + if (s0 >= 0.0 && s0 <= 1.0) + num_s = 1; + } + + if (num_s == 0) + return 0; + else { + float rcp_len2 = 1 / (ray[0]*ray[0] + ray[1]*ray[1]); + float rayn_x = ray[0] * rcp_len2, rayn_y = ray[1] * rcp_len2; + + float q0d = q0[0]*rayn_x + q0[1]*rayn_y; + float q1d = q1[0]*rayn_x + q1[1]*rayn_y; + float q2d = q2[0]*rayn_x + q2[1]*rayn_y; + float rod = orig[0]*rayn_x + orig[1]*rayn_y; + + float q10d = q1d - q0d; + float q20d = q2d - q0d; + float q0rd = q0d - rod; + + hits[0][0] = q0rd + s0*(2.0f - 2.0f*s0)*q10d + s0*s0*q20d; + hits[0][1] = a*s0+b; + + if (num_s > 1) { + hits[1][0] = q0rd + s1*(2.0f - 2.0f*s1)*q10d + s1*s1*q20d; + hits[1][1] = a*s1+b; + return 2; + } else { + return 1; + } + } +} + +static int equal(float *a, float *b) +{ + return (a[0] == b[0] && a[1] == b[1]); +} + +static int stbtt__compute_crossings_x(float x, float y, int nverts, stbtt_vertex *verts) +{ + int i; + float orig[2], ray[2] = { 1, 0 }; + float y_frac; + int winding = 0; + + // make sure y never passes through a vertex of the shape + y_frac = (float) STBTT_fmod(y, 1.0f); + if (y_frac < 0.01f) + y += 0.01f; + else if (y_frac > 0.99f) + y -= 0.01f; + + orig[0] = x; + orig[1] = y; + + // test a ray from (-infinity,y) to (x,y) + for (i=0; i < nverts; ++i) { + if (verts[i].type == STBTT_vline) { + int x0 = (int) verts[i-1].x, y0 = (int) verts[i-1].y; + int x1 = (int) verts[i ].x, y1 = (int) verts[i ].y; + if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { + float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; + if (x_inter < x) + winding += (y0 < y1) ? 1 : -1; + } + } + if (verts[i].type == STBTT_vcurve) { + int x0 = (int) verts[i-1].x , y0 = (int) verts[i-1].y ; + int x1 = (int) verts[i ].cx, y1 = (int) verts[i ].cy; + int x2 = (int) verts[i ].x , y2 = (int) verts[i ].y ; + int ax = STBTT_min(x0,STBTT_min(x1,x2)), ay = STBTT_min(y0,STBTT_min(y1,y2)); + int by = STBTT_max(y0,STBTT_max(y1,y2)); + if (y > ay && y < by && x > ax) { + float q0[2],q1[2],q2[2]; + float hits[2][2]; + q0[0] = (float)x0; + q0[1] = (float)y0; + q1[0] = (float)x1; + q1[1] = (float)y1; + q2[0] = (float)x2; + q2[1] = (float)y2; + if (equal(q0,q1) || equal(q1,q2)) { + x0 = (int)verts[i-1].x; + y0 = (int)verts[i-1].y; + x1 = (int)verts[i ].x; + y1 = (int)verts[i ].y; + if (y > STBTT_min(y0,y1) && y < STBTT_max(y0,y1) && x > STBTT_min(x0,x1)) { + float x_inter = (y - y0) / (y1 - y0) * (x1-x0) + x0; + if (x_inter < x) + winding += (y0 < y1) ? 1 : -1; + } + } else { + int num_hits = stbtt__ray_intersect_bezier(orig, ray, q0, q1, q2, hits); + if (num_hits >= 1) + if (hits[0][0] < 0) + winding += (hits[0][1] < 0 ? -1 : 1); + if (num_hits >= 2) + if (hits[1][0] < 0) + winding += (hits[1][1] < 0 ? -1 : 1); + } + } + } + } + return winding; +} + +static float stbtt__cuberoot( float x ) +{ + if (x<0) + return -(float) STBTT_pow(-x,1.0f/3.0f); + else + return (float) STBTT_pow( x,1.0f/3.0f); +} + +// x^3 + a*x^2 + b*x + c = 0 +static int stbtt__solve_cubic(float a, float b, float c, float* r) +{ + float s = -a / 3; + float p = b - a*a / 3; + float q = a * (2*a*a - 9*b) / 27 + c; + float p3 = p*p*p; + float d = q*q + 4*p3 / 27; + if (d >= 0) { + float z = (float) STBTT_sqrt(d); + float u = (-q + z) / 2; + float v = (-q - z) / 2; + u = stbtt__cuberoot(u); + v = stbtt__cuberoot(v); + r[0] = s + u + v; + return 1; + } else { + float u = (float) STBTT_sqrt(-p/3); + float v = (float) STBTT_acos(-STBTT_sqrt(-27/p3) * q / 2) / 3; // p3 must be negative, since d is negative + float m = (float) STBTT_cos(v); + float n = (float) STBTT_cos(v-3.141592/2)*1.732050808f; + r[0] = s + u * 2 * m; + r[1] = s - u * (m + n); + r[2] = s - u * (m - n); + + //STBTT_assert( STBTT_fabs(((r[0]+a)*r[0]+b)*r[0]+c) < 0.05f); // these asserts may not be safe at all scales, though they're in bezier t parameter units so maybe? + //STBTT_assert( STBTT_fabs(((r[1]+a)*r[1]+b)*r[1]+c) < 0.05f); + //STBTT_assert( STBTT_fabs(((r[2]+a)*r[2]+b)*r[2]+c) < 0.05f); + return 3; + } +} + +STBTT_DEF unsigned char * stbtt_GetGlyphSDF(const stbtt_fontinfo *info, float scale, int glyph, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + float scale_x = scale, scale_y = scale; + int ix0,iy0,ix1,iy1; + int w,h; + unsigned char *data; + + if (scale == 0) return NULL; + + stbtt_GetGlyphBitmapBoxSubpixel(info, glyph, scale, scale, 0.0f,0.0f, &ix0,&iy0,&ix1,&iy1); + + // if empty, return NULL + if (ix0 == ix1 || iy0 == iy1) + return NULL; + + ix0 -= padding; + iy0 -= padding; + ix1 += padding; + iy1 += padding; + + w = (ix1 - ix0); + h = (iy1 - iy0); + + if (width ) *width = w; + if (height) *height = h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + // invert for y-downwards bitmaps + scale_y = -scale_y; + + { + // distance from singular values (in the same units as the pixel grid) + const float eps = 1./1024, eps2 = eps*eps; + int x,y,i,j; + float *precompute; + stbtt_vertex *verts; + int num_verts = stbtt_GetGlyphShape(info, glyph, &verts); + data = (unsigned char *) STBTT_malloc(w * h, info->userdata); + precompute = (float *) STBTT_malloc(num_verts * sizeof(float), info->userdata); + + for (i=0,j=num_verts-1; i < num_verts; j=i++) { + if (verts[i].type == STBTT_vline) { + float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + float x1 = verts[j].x*scale_x, y1 = verts[j].y*scale_y; + float dist = (float) STBTT_sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0)); + precompute[i] = (dist < eps) ? 0.0f : 1.0f / dist; + } else if (verts[i].type == STBTT_vcurve) { + float x2 = verts[j].x *scale_x, y2 = verts[j].y *scale_y; + float x1 = verts[i].cx*scale_x, y1 = verts[i].cy*scale_y; + float x0 = verts[i].x *scale_x, y0 = verts[i].y *scale_y; + float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + float len2 = bx*bx + by*by; + if (len2 >= eps2) + precompute[i] = 1.0f / len2; + else + precompute[i] = 0.0f; + } else + precompute[i] = 0.0f; + } + + for (y=iy0; y < iy1; ++y) { + for (x=ix0; x < ix1; ++x) { + float val; + float min_dist = 999999.0f; + float sx = (float) x + 0.5f; + float sy = (float) y + 0.5f; + float x_gspace = (sx / scale_x); + float y_gspace = (sy / scale_y); + + int winding = stbtt__compute_crossings_x(x_gspace, y_gspace, num_verts, verts); // @OPTIMIZE: this could just be a rasterization, but needs to be line vs. non-tesselated curves so a new path + + for (i=0; i < num_verts; ++i) { + float x0 = verts[i].x*scale_x, y0 = verts[i].y*scale_y; + + if (verts[i].type == STBTT_vline && precompute[i] != 0.0f) { + float x1 = verts[i-1].x*scale_x, y1 = verts[i-1].y*scale_y; + + float dist,dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (float) STBTT_sqrt(dist2); + + // coarse culling against bbox + //if (sx > STBTT_min(x0,x1)-min_dist && sx < STBTT_max(x0,x1)+min_dist && + // sy > STBTT_min(y0,y1)-min_dist && sy < STBTT_max(y0,y1)+min_dist) + dist = (float) STBTT_fabs((x1-x0)*(y0-sy) - (y1-y0)*(x0-sx)) * precompute[i]; + STBTT_assert(i != 0); + if (dist < min_dist) { + // check position along line + // x' = x0 + t*(x1-x0), y' = y0 + t*(y1-y0) + // minimize (x'-sx)*(x'-sx)+(y'-sy)*(y'-sy) + float dx = x1-x0, dy = y1-y0; + float px = x0-sx, py = y0-sy; + // minimize (px+t*dx)^2 + (py+t*dy)^2 = px*px + 2*px*dx*t + t^2*dx*dx + py*py + 2*py*dy*t + t^2*dy*dy + // derivative: 2*px*dx + 2*py*dy + (2*dx*dx+2*dy*dy)*t, set to 0 and solve + float t = -(px*dx + py*dy) / (dx*dx + dy*dy); + if (t >= 0.0f && t <= 1.0f) + min_dist = dist; + } + } else if (verts[i].type == STBTT_vcurve) { + float x2 = verts[i-1].x *scale_x, y2 = verts[i-1].y *scale_y; + float x1 = verts[i ].cx*scale_x, y1 = verts[i ].cy*scale_y; + float box_x0 = STBTT_min(STBTT_min(x0,x1),x2); + float box_y0 = STBTT_min(STBTT_min(y0,y1),y2); + float box_x1 = STBTT_max(STBTT_max(x0,x1),x2); + float box_y1 = STBTT_max(STBTT_max(y0,y1),y2); + // coarse culling against bbox to avoid computing cubic unnecessarily + if (sx > box_x0-min_dist && sx < box_x1+min_dist && sy > box_y0-min_dist && sy < box_y1+min_dist) { + int num=0; + float ax = x1-x0, ay = y1-y0; + float bx = x0 - 2*x1 + x2, by = y0 - 2*y1 + y2; + float mx = x0 - sx, my = y0 - sy; + float res[3] = {0.f,0.f,0.f}; + float px,py,t,it,dist2; + float a_inv = precompute[i]; + if (a_inv == 0.0) { // if a_inv is 0, it's 2nd degree so use quadratic formula + float a = 3*(ax*bx + ay*by); + float b = 2*(ax*ax + ay*ay) + (mx*bx+my*by); + float c = mx*ax+my*ay; + if (STBTT_fabs(a) < eps2) { // if a is 0, it's linear + if (STBTT_fabs(b) >= eps2) { + res[num++] = -c/b; + } + } else { + float discriminant = b*b - 4*a*c; + if (discriminant < 0) + num = 0; + else { + float root = (float) STBTT_sqrt(discriminant); + res[0] = (-b - root)/(2*a); + res[1] = (-b + root)/(2*a); + num = 2; // don't bother distinguishing 1-solution case, as code below will still work + } + } + } else { + float b = 3*(ax*bx + ay*by) * a_inv; // could precompute this as it doesn't depend on sample point + float c = (2*(ax*ax + ay*ay) + (mx*bx+my*by)) * a_inv; + float d = (mx*ax+my*ay) * a_inv; + num = stbtt__solve_cubic(b, c, d, res); + } + dist2 = (x0-sx)*(x0-sx) + (y0-sy)*(y0-sy); + if (dist2 < min_dist*min_dist) + min_dist = (float) STBTT_sqrt(dist2); + + if (num >= 1 && res[0] >= 0.0f && res[0] <= 1.0f) { + t = res[0], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (float) STBTT_sqrt(dist2); + } + if (num >= 2 && res[1] >= 0.0f && res[1] <= 1.0f) { + t = res[1], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (float) STBTT_sqrt(dist2); + } + if (num >= 3 && res[2] >= 0.0f && res[2] <= 1.0f) { + t = res[2], it = 1.0f - t; + px = it*it*x0 + 2*t*it*x1 + t*t*x2; + py = it*it*y0 + 2*t*it*y1 + t*t*y2; + dist2 = (px-sx)*(px-sx) + (py-sy)*(py-sy); + if (dist2 < min_dist * min_dist) + min_dist = (float) STBTT_sqrt(dist2); + } + } + } + } + if (winding == 0) + min_dist = -min_dist; // if outside the shape, value is negative + val = onedge_value + pixel_dist_scale * min_dist; + if (val < 0) + val = 0; + else if (val > 255) + val = 255; + data[(y-iy0)*w+(x-ix0)] = (unsigned char) val; + } + } + STBTT_free(precompute, info->userdata); + STBTT_free(verts, info->userdata); + } + return data; +} + +STBTT_DEF unsigned char * stbtt_GetCodepointSDF(const stbtt_fontinfo *info, float scale, int codepoint, int padding, unsigned char onedge_value, float pixel_dist_scale, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphSDF(info, scale, stbtt_FindGlyphIndex(info, codepoint), padding, onedge_value, pixel_dist_scale, width, height, xoff, yoff); +} + +STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata) +{ + STBTT_free(bitmap, userdata); +} + +////////////////////////////////////////////////////////////////////////////// +// +// font name matching -- recommended not to use this +// + +// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string +static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) +{ + stbtt_int32 i=0; + + // convert utf16 to utf8 and compare the results while converting + while (len2) { + stbtt_uint16 ch = s2[0]*256 + s2[1]; + if (ch < 0x80) { + if (i >= len1) return -1; + if (s1[i++] != ch) return -1; + } else if (ch < 0x800) { + if (i+1 >= len1) return -1; + if (s1[i++] != 0xc0 + (ch >> 6)) return -1; + if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; + } else if (ch >= 0xd800 && ch < 0xdc00) { + stbtt_uint32 c; + stbtt_uint16 ch2 = s2[2]*256 + s2[3]; + if (i+3 >= len1) return -1; + c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; + if (s1[i++] != 0xf0 + (c >> 18)) return -1; + if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; + s2 += 2; // plus another 2 below + len2 -= 2; + } else if (ch >= 0xdc00 && ch < 0xe000) { + return -1; + } else { + if (i+2 >= len1) return -1; + if (s1[i++] != 0xe0 + (ch >> 12)) return -1; + if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; + } + s2 += 2; + len2 -= 2; + } + return i; +} + +static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len1, char *s2, int len2) +{ + return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); +} + +// returns results in whatever encoding you request... but note that 2-byte encodings +// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare +STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) +{ + stbtt_int32 i,count,stringOffset; + stbtt_uint8 *fc = font->data; + stbtt_uint32 offset = font->fontstart; + stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return NULL; + + count = ttUSHORT(fc+nm+2); + stringOffset = nm + ttUSHORT(fc+nm+4); + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) + && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { + *length = ttUSHORT(fc+loc+8); + return (const char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); + } + } + return NULL; +} + +static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) +{ + stbtt_int32 i; + stbtt_int32 count = ttUSHORT(fc+nm+2); + stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); + + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + stbtt_int32 id = ttUSHORT(fc+loc+6); + if (id == target_id) { + // find the encoding + stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); + + // is this a Unicode encoding? + if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { + stbtt_int32 slen = ttUSHORT(fc+loc+8); + stbtt_int32 off = ttUSHORT(fc+loc+10); + + // check if there's a prefix match + stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); + if (matchlen >= 0) { + // check for target_id+1 immediately following, with same encoding & language + if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { + slen = ttUSHORT(fc+loc+12+8); + off = ttUSHORT(fc+loc+12+10); + if (slen == 0) { + if (matchlen == nlen) + return 1; + } else if (matchlen < nlen && name[matchlen] == ' ') { + ++matchlen; + if (stbtt_CompareUTF8toUTF16_bigendian_internal((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) + return 1; + } + } else { + // if nothing immediately following + if (matchlen == nlen) + return 1; + } + } + } + + // @TODO handle other encodings + } + } + return 0; +} + +static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) +{ + stbtt_int32 nlen = (stbtt_int32) STBTT_strlen((char *) name); + stbtt_uint32 nm,hd; + if (!stbtt__isfont(fc+offset)) return 0; + + // check italics/bold/underline flags in macStyle... + if (flags) { + hd = stbtt__find_table(fc, offset, "head"); + if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; + } + + nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return 0; + + if (flags) { + // if we checked the macStyle flags, then just check the family and ignore the subfamily + if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } else { + if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } + + return 0; +} + +static int stbtt_FindMatchingFont_internal(unsigned char *font_collection, char *name_utf8, stbtt_int32 flags) +{ + stbtt_int32 i; + for (i=0;;++i) { + stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); + if (off < 0) return off; + if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) + return off; + } +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif + +STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset, + float pixel_height, unsigned char *pixels, int pw, int ph, + int first_char, int num_chars, stbtt_bakedchar *chardata) +{ + return stbtt_BakeFontBitmap_internal((unsigned char *) data, offset, pixel_height, pixels, pw, ph, first_char, num_chars, chardata); +} + +STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index) +{ + return stbtt_GetFontOffsetForIndex_internal((unsigned char *) data, index); +} + +STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data) +{ + return stbtt_GetNumberOfFonts_internal((unsigned char *) data); +} + +STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset) +{ + return stbtt_InitFont_internal(info, (unsigned char *) data, offset); +} + +STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags) +{ + return stbtt_FindMatchingFont_internal((unsigned char *) fontdata, (char *) name, flags); +} + +STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) +{ + return stbtt_CompareUTF8toUTF16_bigendian_internal((char *) s1, len1, (char *) s2, len2); +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#endif // STB_TRUETYPE_IMPLEMENTATION + + +// FULL VERSION HISTORY +// +// 1.25 (2021-07-11) many fixes +// 1.24 (2020-02-05) fix warning +// 1.23 (2020-02-02) query SVG data for glyphs; query whole kerning table (but only kern not GPOS) +// 1.22 (2019-08-11) minimize missing-glyph duplication; fix kerning if both 'GPOS' and 'kern' are defined +// 1.21 (2019-02-25) fix warning +// 1.20 (2019-02-07) PackFontRange skips missing codepoints; GetScaleFontVMetrics() +// 1.19 (2018-02-11) OpenType GPOS kerning (horizontal only), STBTT_fmod +// 1.18 (2018-01-29) add missing function +// 1.17 (2017-07-23) make more arguments const; doc fix +// 1.16 (2017-07-12) SDF support +// 1.15 (2017-03-03) make more arguments const +// 1.14 (2017-01-16) num-fonts-in-TTC function +// 1.13 (2017-01-02) support OpenType fonts, certain Apple fonts +// 1.12 (2016-10-25) suppress warnings about casting away const with -Wcast-qual +// 1.11 (2016-04-02) fix unused-variable warning +// 1.10 (2016-04-02) allow user-defined fabs() replacement +// fix memory leak if fontsize=0.0 +// fix warning from duplicate typedef +// 1.09 (2016-01-16) warning fix; avoid crash on outofmem; use alloc userdata for PackFontRanges +// 1.08 (2015-09-13) document stbtt_Rasterize(); fixes for vertical & horizontal edges +// 1.07 (2015-08-01) allow PackFontRanges to accept arrays of sparse codepoints; +// allow PackFontRanges to pack and render in separate phases; +// fix stbtt_GetFontOFfsetForIndex (never worked for non-0 input?); +// fixed an assert() bug in the new rasterizer +// replace assert() with STBTT_assert() in new rasterizer +// 1.06 (2015-07-14) performance improvements (~35% faster on x86 and x64 on test machine) +// also more precise AA rasterizer, except if shapes overlap +// remove need for STBTT_sort +// 1.05 (2015-04-15) fix misplaced definitions for STBTT_STATIC +// 1.04 (2015-04-15) typo in example +// 1.03 (2015-04-12) STBTT_STATIC, fix memory leak in new packing, various fixes +// 1.02 (2014-12-10) fix various warnings & compile issues w/ stb_rect_pack, C++ +// 1.01 (2014-12-08) fix subpixel position when oversampling to exactly match +// non-oversampled; STBTT_POINT_SIZE for packed case only +// 1.00 (2014-12-06) add new PackBegin etc. API, w/ support for oversampling +// 0.99 (2014-09-18) fix multiple bugs with subpixel rendering (ryg) +// 0.9 (2014-08-07) support certain mac/iOS fonts without an MS platformID +// 0.8b (2014-07-07) fix a warning +// 0.8 (2014-05-25) fix a few more warnings +// 0.7 (2013-09-25) bugfix: subpixel glyph bug fixed in 0.5 had come back +// 0.6c (2012-07-24) improve documentation +// 0.6b (2012-07-20) fix a few more warnings +// 0.6 (2012-07-17) fix warnings; added stbtt_ScaleForMappingEmToPixels, +// stbtt_GetFontBoundingBox, stbtt_IsGlyphEmpty +// 0.5 (2011-12-09) bugfixes: +// subpixel glyph renderer computed wrong bounding box +// first vertex of shape can be off-curve (FreeSans) +// 0.4b (2011-12-03) fixed an error in the font baking example +// 0.4 (2011-12-01) kerning, subpixel rendering (tor) +// bugfixes for: +// codepoint-to-glyph conversion using table fmt=12 +// codepoint-to-glyph conversion using table fmt=4 +// stbtt_GetBakedQuad with non-square texture (Zer) +// updated Hello World! sample to use kerning and subpixel +// fixed some warnings +// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) +// userdata, malloc-from-userdata, non-zero fill (stb) +// 0.2 (2009-03-11) Fix unsigned/signed char warnings +// 0.1 (2009-03-09) First public release +// + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/meson.build b/meson.build new file mode 100644 index 0000000..1508407 --- /dev/null +++ b/meson.build @@ -0,0 +1,64 @@ +project( + 'pgpl', + 'c', + 'cpp', + version: '0.1', + default_options: ['warning_level=3', 'c_std=c99', 'cpp_std=c++11'], +) + +include = include_directories('include') + +cc = meson.get_compiler('c') + +link_args = [] + +if target_machine.system() == 'windows' or target_machine.system() == 'cygwin' + link_args = ['-static'] +endif + +lib = both_libraries( + 'pgpl', + 'src/pgpl.c', + 'src/thread.c', + 'src/timer.c', + 'src/vector.c', + 'src/window/window.c', + 'src/window/window-x11.c', + 'src/window/window-win32.c', + 'src/window/thread.c', + 'src/render/shapes.c', + 'src/render/texture.c', + 'src/render/font.c', + 'src/gui/gui.c', + 'src/gui/helpers.c', + 'src/gui/widgets/text.c', + 'src/gui/widgets/button.c', + 'src/gui/widgets/container.c', + include_directories: include, + dependencies: [ + dependency('gl'), + dependency('threads'), + dependency('x11', required: false), + cc.find_library('m', required: false), + ], + install: true, + link_args: link_args, +) + +test = executable( + 'pgpl_test', + 'tests/program.c', + include_directories: include, + link_with: lib.get_static_lib(), + link_args: link_args, +) + +shared_library( + 'pgpl_plugin_test', + 'tests/plugin.cpp', + include_directories: include, + link_with: lib.get_static_lib(), + link_args: link_args, +) + +test('pgpl_test', test) diff --git a/roboto.ttf b/roboto.ttf new file mode 100644 index 0000000000000000000000000000000000000000..bba55f616c811c4ee31535667dd2ed30229e5e71 GIT binary patch literal 468308 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

Q(u6ZZl>(a08KItzpa5=rSPnQ_ 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

_ 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

j{ zE9Fi5@vHj4Ky9RP091O@tW(2TFM96a3z0Ho9t3)S`lXQHHY-%6(6##l>B*TIVjJ+F z{IyK=CC6El0jX&zV}8%qkM+|B8C?v!)Zp0Z`XVe%#4`X_qFKe<7?C+9WF2VgBhauGG>?%rC? zrUmo1vJ}@_I0H^Qc}Q@tKM&J%O<96$3rEbhaIVCvR9{b9q6%TZAV$a8td8ZHy`dKI zLkLY;Fxvq=={pDS$why(h>Yew{71&?lZx&N*XxtrR`P{gt>)=o(d&iwLZ11U`Q(M( zPn${so+-wo^Ljb?OHJfi9iCG3xGOv@7Xzzs-dhrgO?v?m_GJ?COj3FJv0H?Zp)NKo z%aj}i#PbnKS@J?^E>!b@k26et8XrqoJ}EW4kFI>@YoT|2I~NrHb%vt*XNE zP(tDkI!9sxAuwX!3!$HD6D9J`S&UMYOE{fKbmHC)(wO*o9(hW9*j0nFs!|gLjw$9( z`1Db;T9RE0{Xo_TB_Mzkff;n4{u_8vb{x;^MNKl-5SwtIxtn)>D^ z6n6Ome<$F}v~2c;;a$6NR~S;-PaFC`w9?6})lrG2>?o;%0GvVU7T}(d8SJ@sAIR9| zVbgyj=7&W4K1n)eFJtDuj_gjHeE{CvAHPN@Azhb&Jvu(EL$k*n?HPyIYVK$$*(# z_*1SAatNBJ|0|_a^iW;l*7bdX58%r6f!hmNiSOIJxf}Y$KnHCbSB@VKZ-m~ zpYKZA(GW5Qp{Bg8a;NB+S(iWH_1+kQfz;z{^)6t!5Uyo2LZ~Jbtl1bBzpp%;^~7Gc z-GN-Yk@w*L!i$vC{mt2^Q6%@T_!iz_{|8TBv_OYK9P<9$81V<2=Nm=!BVt3th2-tycEANh6_P?v+ZZieUa zL(B8{Vcxe_=VUrMdPiT5QJ+_y6z_Qa7r(%C(_yvoN~iOqk3KpOj&)=X?%uI&+qTYN zRYf=yudcpz<^ydN$@RS*D}yU9z8F#n=*{3B80 zgUOtOd%JtJ6OL7ObabGP(LogowhW66st$$rzj)6*_dK!jV06Tov17-+p!Ex>svAO~ z>g~_mci(-B4jeJ@yUpr0b=xuf_H~Dbj5y=GN#nNY!aq>;ZJ1dU5{*7H1FR~hI}*sjA*^Nqi=10(Sd0+Nc4noC!b&Jw7 zYxz}<1w#QJs-gHojhB6(nmxHo2};r*IhqJc;_TM?{{qehAy!Bh;TVp7=YI4GCO=$^i=H1-Yp zQmoC5Vn160V*(Gf&v+Zmrvmf;0nE<^=2rsqt1bDpC+3}W`Ri*|ZrGcS z)q&gV>mvKNty{U~^~*0Er?$Pj_>Xtt_3y8IxL1$6?Ad20PDHjcuxr=mj+RK~;I_7r z!{dRL`oRrH9C7NGuDRx#%O{;UvTe=Nf4ukJd;k5l1)0o()Jb=pd`6?ww`;@etMPjC zy{+4wQJ+3#_MGS5+8!H!)i?3_$~nXP-h5)tm%jAuvxu7l4Gq;!%W+O@Xyc|GU0Ezm z=azTheg1bCGCXJD`b~`^KXb+O>C-PiCHC^mG04nK+3#k*7ixXrspTK+PlXPAu>9!< zW}KV-9)5dM_D41UGUw@+-`kC4@7n#|vZv=bz-n;;ed?nYm;; z6y(NZkSNRmrc^;__=)rEF}Na;BuWkY$Y(&RwO$t6j0-k=2L8{mTsM=d?85+H$N-VY zDBlLi38v-?W+gu6pc0nTnE~ zbW!o!Ucz*fz!@fiMQ4zjgk0VVbNVofr^OYJX476UEY4y6c}r!K(MwPgvd)?6B0QsJ z#`{}*Sa&{{?AQp^{C>T)DnhNJ-HzIGRipUzoO^LHo(;t8R%X;I^zWTK>(;8+`LBE#WzNSw<}I)o|M z^x-@B3E5xM8jbsAo*dZw3gKz_%$y)M*!1k{Gd=s(dQoki(HL$m-r?-P+(YtJFzs*p z@<Rgq<%vP V$BGt0hpG?xH@A)?7r;A-{{v>9Kezw@ literal 0 HcmV?d00001 diff --git a/src/gui/gui.c b/src/gui/gui.c new file mode 100644 index 0000000..e45b328 --- /dev/null +++ b/src/gui/gui.c @@ -0,0 +1,125 @@ + +#include +#include +#include + +static bool pgpl_gui_internal_event_loop(PGPL_Window *window, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data, + void *user_data) { + PGPL_Gui *gui = user_data; + + pgpl_mutex_lock(gui->mutex); + + if (event_type == PGPL_WINDOW_EVENT_NONE) { + } else if (event_type == PGPL_WINDOW_EVENT_RENDER_REQUEST) { + PGPL_Renderer *renderer = + pgpl_window_start_render(window, gui->theme.background_color); + uint32_t width, height; + uint32_t length = pgpl_vector_get_length(gui->widgets); + + pgpl_window_get_size(window, &width, &height); + + for (uint32_t i = 0; i < length; i++) { + PGPL_GuiWidget *widget = + *(PGPL_GuiWidget **)pgpl_vector_get_index(gui->widgets, i); + PGPL_GuiTheme *theme = &gui->theme; + + if (widget->use_theme_override) { + theme = &widget->theme_override; + } + + pgpl_gui_widget_render_full(widget, renderer, theme, 0, 0, width, height); + } + + pgpl_window_finish_render(window, renderer); + } else if (event_type == PGPL_WINDOW_EVENT_CLOSE) { + pgpl_gui_destroy(gui, true); + return false; + } else if (event_type == PGPL_WINDOW_EVENT_ERROR) { + printf("PGPL_Window has experienced an unexpected error!\nExiting..."); + } else { + uint32_t width, height; + uint32_t length = pgpl_vector_get_length(gui->widgets); + + pgpl_window_get_size(window, &width, &height); + + for (uint32_t i = 0; i < length; i++) { + PGPL_GuiWidget *widget = + *(PGPL_GuiWidget **)pgpl_vector_get_index(gui->widgets, i); + widget->event(widget, &gui->theme, gui, event_type, event_data, + widget->offset_x, widget->offset_y, width, height); + } + } + + pgpl_mutex_unlock(gui->mutex); + + return true; +} + +PGPL_Gui *pgpl_gui_create(const char *title, uint32_t width, uint32_t height, + int32_t x, int32_t y, PGPL_GuiTheme *theme, + void *app_data) { + PGPL_Gui *gui = malloc(sizeof(*gui)); + gui->app_data = app_data; + gui->widgets = pgpl_vector_create(sizeof(PGPL_GuiWidget *)); + gui->theme = *theme; + gui->window_thread = pgpl_window_thread_create( + title, width, height, x, y, pgpl_gui_internal_event_loop, gui); + gui->mutex = pgpl_mutex_create(); + return gui; +} + +void pgpl_gui_destroy(PGPL_Gui *gui, bool internal) { + uint32_t length = pgpl_vector_get_length(gui->widgets); + + if (!internal) { + pgpl_mutex_lock(gui->mutex); + } + + for (uint32_t i = 0; i < length; i++) { + PGPL_GuiWidget *widget = + *(PGPL_GuiWidget **)pgpl_vector_get_index(gui->widgets, i); + widget->destroy(widget); + } + + pgpl_mutex_destroy(gui->mutex); + + if (!internal) { + pgpl_window_thread_destroy(gui->window_thread); + } + + pgpl_vector_destroy(gui->widgets); + free(gui); +} + +void pgpl_gui_run_and_show(PGPL_Gui *gui, bool wait) { + pgpl_window_thread_show(gui->window_thread); + if (wait) { + pgpl_window_thread_await_destruction(gui->window_thread); + } +} + +void pgpl_gui_widget_add(PGPL_Gui *gui, PGPL_GuiWidget *widget) { + pgpl_mutex_lock(gui->mutex); + pgpl_vector_push_back(gui->widgets, &widget); + pgpl_mutex_unlock(gui->mutex); +} + +uint32_t pgpl_gui_widget_amount(PGPL_Gui *gui) { + return pgpl_vector_get_length(gui->widgets); +} + +void pgpl_gui_widget_remove(PGPL_Gui *gui, uint32_t index) { + pgpl_mutex_lock(gui->mutex); + PGPL_GuiWidget *widget = + *(PGPL_GuiWidget **)pgpl_vector_delete_index(gui->widgets, index); + widget->destroy(widget); + pgpl_mutex_unlock(gui->mutex); +} + +PGPL_GuiWidget *pgpl_gui_widget_get(PGPL_Gui *gui, uint32_t index) { + pgpl_mutex_lock(gui->mutex); + return *(PGPL_GuiWidget **)pgpl_vector_get_index(gui->widgets, index); + pgpl_mutex_unlock(gui->mutex); +} diff --git a/src/gui/helpers.c b/src/gui/helpers.c new file mode 100644 index 0000000..dfb442c --- /dev/null +++ b/src/gui/helpers.c @@ -0,0 +1,187 @@ +#include + +void pgpl_gui_theme_configure(PGPL_GuiTheme *theme, PGPL_Color base_color, + double content_font_size, PGPL_Font *font) { + theme->background_color = pgpl_color_divide(base_color, 8); + + theme->widget_background_color[0] = pgpl_color_divide(base_color, 5); + theme->widget_background_color[1] = pgpl_color_divide(base_color, 4); + theme->widget_background_color[2] = pgpl_color_divide(base_color, 3); + + theme->text_color[0] = pgpl_color_divide(base_color, 1.5); + theme->text_color[1] = pgpl_color_divide(base_color, 1.25); + theme->text_color[2] = base_color; + + theme->font_size[0] = content_font_size * 3; + theme->font_size[1] = content_font_size * 2; + theme->font_size[2] = content_font_size; + + theme->margin.top = content_font_size / 6; + theme->margin.left = theme->margin.top; + theme->margin.bottom = theme->margin.top; + theme->margin.right = theme->margin.top; + + theme->border.top = content_font_size / 12; + theme->border.left = theme->border.top; + theme->border.bottom = theme->border.top; + theme->border.right = theme->border.top; + + theme->padding.top = content_font_size / 6; + theme->padding.left = theme->padding.top; + theme->padding.bottom = theme->padding.top; + theme->padding.right = theme->padding.top; + + theme->font = font; +} + +void pgpl_gui_widget_max_content_size(PGPL_GuiWidget *widget, + PGPL_GuiTheme *theme, double *width, + double *height, double max_width, + double max_height) { + *width = max_width; + *height = max_height; + + if (!widget->ignore_margin) { + *width -= theme->margin.left + theme->margin.right; + *height -= theme->margin.top + theme->margin.bottom; + } + + if (!widget->ignore_border) { + *width -= theme->border.left + theme->border.right; + *height -= theme->border.top + theme->border.bottom; + } + + if (!widget->ignore_padding) { + *width -= theme->padding.left + theme->padding.right; + *height -= theme->padding.top + theme->padding.bottom; + } +} + +void pgpl_gui_widget_render_full(PGPL_GuiWidget *widget, + PGPL_Renderer *renderer, PGPL_GuiTheme *theme, + double x, double y, double max_width, + double max_height) { + double width, height; + + if (widget->use_theme_override) { + theme = &widget->theme_override; + } + + x += +widget->offset_x; + y += +widget->offset_y; + + widget->get_content_size(widget, theme, &width, &height, max_width, + max_height); + + if (!widget->expand_x) { + max_width = width; + if (!widget->ignore_margin) { + max_width += theme->margin.left + theme->margin.right; + } + if (!widget->ignore_border) { + max_width += theme->border.left + theme->border.right; + } + if (!widget->ignore_padding) { + max_width += theme->padding.left + theme->padding.right; + } + } + + if (!widget->expand_y) { + max_height = height; + if (!widget->ignore_margin) { + max_height += theme->margin.top + theme->margin.bottom; + } + if (!widget->ignore_border) { + max_height += theme->border.top + theme->border.bottom; + } + if (!widget->ignore_padding) { + max_height += theme->padding.top + theme->padding.bottom; + } + } + + if (!widget->ignore_margin) { + x += theme->margin.left; + y += theme->margin.top; + + max_width -= theme->margin.left + theme->margin.right; + max_height -= theme->margin.top + theme->margin.bottom; + } + + if (widget->border) { + pgpl_render_rectangle(renderer, theme->text_color[widget->gui_color], x, y, + max_width, max_height); + } + + if (!widget->ignore_border) { + x += theme->border.left; + y += theme->border.top; + + max_width -= theme->border.left + theme->border.right; + max_height -= theme->border.top + theme->border.bottom; + } + + if (widget->background) { + pgpl_render_rectangle(renderer, + theme->widget_background_color[widget->gui_color], x, + y, max_width, max_height); + } else { + pgpl_render_rectangle(renderer, theme->background_color, x, y, max_width, + max_height); + } + + if (!widget->ignore_padding) { + x += theme->padding.left; + y += theme->padding.top; + + max_width -= theme->padding.left + theme->padding.right; + max_height -= theme->padding.top + theme->padding.bottom; + } + + x += (max_width - width) / 2; + y += (max_height - height) / 2; + + widget->render_content(widget, renderer, theme, x, y, max_width, max_height); +} + +bool pgpl_gui_widget_within_bounds(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double widget_x, double widget_y, + double max_width, double max_height, + double x, double y) { + (void)widget; + + widget_x += theme->margin.left; + widget_y += theme->margin.top; + + max_width -= theme->margin.left + theme->margin.right; + max_height -= theme->margin.top + theme->margin.bottom; + + if ((x >= widget_x && x <= (widget_x + max_width)) && + (y >= widget_y && y <= (widget_y + max_height))) { + return true; + } + + return false; +} + +void pgpl_gui_widget_configure(PGPL_GuiWidget *widget, double offset_x, + double offset_y, bool expand_x, bool expand_y, + bool border, bool background, + PGPL_GuiFontSize font_size, + PGPL_GuiTheme *theme_override, + bool use_theme_override, bool ignore_margin, + bool ignore_border, bool ignore_padding) { + widget->offset_x = offset_x; + widget->offset_y = offset_y; + widget->expand_x = expand_x; + widget->expand_y = expand_y; + widget->border = border; + widget->background = background; + widget->font_size = font_size; + if (theme_override != NULL) { + widget->theme_override = *theme_override; + } + widget->use_theme_override = use_theme_override; + widget->ignore_margin = ignore_margin; + widget->ignore_border = ignore_border; + widget->ignore_padding = ignore_padding; +} diff --git a/src/gui/widgets/button.c b/src/gui/widgets/button.c new file mode 100644 index 0000000..f88930a --- /dev/null +++ b/src/gui/widgets/button.c @@ -0,0 +1,88 @@ +#include +#include + +static void get_content_size(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double *width, double *height, double max_width, + double max_height) { + PGPL_GuiButtonWidget *button_widget = (PGPL_GuiButtonWidget *)widget; + PGPL_Rectangle rect; + + (void)max_width; + (void)max_height; + + pgpl_font_string_dimensions(theme->font, button_widget->text, + theme->font_size[widget->font_size], &rect); + + *width = rect.right - rect.left; + *height = rect.bottom - rect.top; +} + +static void render_content(PGPL_GuiWidget *widget, PGPL_Renderer *renderer, + PGPL_GuiTheme *theme, double x, double y, + double max_width, double max_height) { + PGPL_GuiButtonWidget *button_widget = (PGPL_GuiButtonWidget *)widget; + + (void)max_width; + (void)max_height; + + pgpl_font_render_string(renderer, theme->font, button_widget->text, + theme->text_color[widget->gui_color], x, y, + theme->font_size[widget->font_size]); +} + +static void event(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, PGPL_Gui *gui, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data, double x, double y, + double max_width, double max_height) { + PGPL_GuiButtonWidget *button_widget = (PGPL_GuiButtonWidget *)widget; + + if (event_type == PGPL_WINDOW_EVENT_MOUSE_PRESS || + event_type == PGPL_WINDOW_EVENT_MOUSE_RELEASE || + event_type == PGPL_WINDOW_EVENT_MOUSE_MOVE) { + if (pgpl_gui_widget_within_bounds(widget, theme, x, y, max_width, + max_height, event_data->input_event.x, + event_data->input_event.y)) { + if (event_type == PGPL_WINDOW_EVENT_MOUSE_PRESS && + event_data->input_event.key == PGPL_WINDOW_MOUSE_BUTTON_LEFT) { + widget->gui_color = PGPL_GUI_STATUS_COLOR_ACTIVE; + return; + } else if (event_type == PGPL_WINDOW_EVENT_MOUSE_RELEASE && + event_data->input_event.key == PGPL_WINDOW_MOUSE_BUTTON_LEFT) { + if (widget->gui_color == PGPL_GUI_STATUS_COLOR_ACTIVE) { + button_widget->click_callback(gui->app_data); + } + widget->gui_color = PGPL_GUI_STATUS_COLOR_HOVER; + return; + } else { + if (widget->gui_color != PGPL_GUI_STATUS_COLOR_ACTIVE) { + widget->gui_color = PGPL_GUI_STATUS_COLOR_HOVER; + } + return; + } + } + } + + widget->gui_color = PGPL_GUI_STATUS_COLOR_NORMAL; +} + +static void destroy(PGPL_GuiWidget *widget) { + pgpl_gui_button_widget_destroy((PGPL_GuiButtonWidget *)widget); +} + +PGPL_GuiButtonWidget * +pgpl_gui_button_widget_create(const char *text, + void (*click_callback)(void *app_data)) { + PGPL_GuiButtonWidget *button_widget = calloc(1, sizeof(*button_widget)); + button_widget->parent.id = "PGPL_GuiButtonWidget"; + button_widget->parent.get_content_size = get_content_size; + button_widget->parent.render_content = render_content; + button_widget->parent.event = event; + button_widget->parent.destroy = destroy; + button_widget->text = text; + button_widget->click_callback = click_callback; + return button_widget; +} + +void pgpl_gui_button_widget_destroy(PGPL_GuiButtonWidget *button_widget) { + free(button_widget); +} diff --git a/src/gui/widgets/container.c b/src/gui/widgets/container.c new file mode 100644 index 0000000..ca4636e --- /dev/null +++ b/src/gui/widgets/container.c @@ -0,0 +1,169 @@ +#include +#include + +static void get_content_size(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double *width, double *height, double max_width, + double max_height) { + (void)widget; + pgpl_gui_widget_max_content_size(widget, theme, width, height, max_width, + max_height); +} + +static void render_content(PGPL_GuiWidget *widget, PGPL_Renderer *renderer, + PGPL_GuiTheme *theme, double x, double y, + double max_width, double max_height) { + PGPL_GuiContainerLayout *container_layout = (PGPL_GuiContainerLayout *)widget; + uint32_t length = pgpl_vector_get_length(container_layout->widgets); + + switch (container_layout->direction) { + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL: + max_height /= length; + break; + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_HORIZONTAL: + max_width /= length; + break; + } + + for (uint32_t i = 0; i < length; i++) { + PGPL_GuiWidget *child_widget = + *(PGPL_GuiWidget **)pgpl_vector_get_index(container_layout->widgets, i); + + pgpl_gui_widget_render_full(child_widget, renderer, theme, x, y, max_width, + max_height); + + switch (container_layout->direction) { + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL: + y += max_height; + break; + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_HORIZONTAL: + x += max_width; + break; + } + } +} + +static void event(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, PGPL_Gui *gui, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data, double x, double y, + double max_width, double max_height) { + PGPL_GuiContainerLayout *container_layout = (PGPL_GuiContainerLayout *)widget; + uint32_t length = pgpl_vector_get_length(container_layout->widgets); + + pgpl_gui_widget_max_content_size(widget, theme, &max_width, &max_height, + max_width, max_height); + + switch (container_layout->direction) { + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL: + max_height /= length; + break; + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_HORIZONTAL: + max_width /= length; + break; + } + + if (!widget->ignore_margin) { + x += theme->margin.left; + y += theme->margin.top; + } + + if (!widget->ignore_border) { + x += theme->border.left; + y += theme->border.top; + } + + if (!widget->ignore_padding) { + x += theme->padding.left; + y += theme->padding.top; + } + + for (uint32_t i = 0; i < length; i++) { + PGPL_GuiWidget *child_widget = + *(PGPL_GuiWidget **)pgpl_vector_get_index(container_layout->widgets, i); + + if (child_widget->use_theme_override) { + theme = &child_widget->theme_override; + } + + child_widget->event(child_widget, theme, gui, event_type, event_data, + x + child_widget->offset_x, y + child_widget->offset_y, + max_width, max_height); + + switch (container_layout->direction) { + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL: + y += max_height; + break; + case PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_HORIZONTAL: + x += max_width; + break; + } + } +} + +static void destroy(PGPL_GuiWidget *widget) { + pgpl_gui_container_layout_destroy((PGPL_GuiContainerLayout *)widget); +} + +PGPL_GuiContainerLayout * +pgpl_gui_container_layout_create(PGPL_GuiContainerLayoutDirection direction) { + PGPL_GuiContainerLayout *container_layout = + calloc(1, sizeof(*container_layout)); + container_layout->parent.id = "PGPL_GuiContainerLayout"; + container_layout->parent.get_content_size = get_content_size; + container_layout->parent.render_content = render_content; + container_layout->parent.event = event; + container_layout->parent.destroy = destroy; + container_layout->widgets = pgpl_vector_create(sizeof(PGPL_GuiWidget *)); + container_layout->direction = direction; + container_layout->mutex = pgpl_mutex_create(); + return container_layout; +} + +void pgpl_gui_container_layout_widget_add( + PGPL_GuiContainerLayout *container_layout, PGPL_GuiWidget *widget) { + pgpl_mutex_lock(container_layout->mutex); + pgpl_vector_push_back(container_layout->widgets, &widget); + pgpl_mutex_unlock(container_layout->mutex); +} + +PGPL_GuiWidget * +pgpl_gui_container_layout_widget_get(PGPL_GuiContainerLayout *container_layout, + uint32_t index) { + PGPL_GuiWidget *widget; + pgpl_mutex_lock(container_layout->mutex); + widget = *(PGPL_GuiWidget **)pgpl_vector_delete_index( + container_layout->widgets, index); + pgpl_mutex_unlock(container_layout->mutex); + return widget; +} + +void pgpl_gui_container_layout_widget_delete( + PGPL_GuiContainerLayout *container_layout, uint32_t index) { + PGPL_GuiWidget *widget; + pgpl_mutex_lock(container_layout->mutex); + widget = *(PGPL_GuiWidget **)pgpl_vector_delete_index( + container_layout->widgets, index); + widget->destroy(widget); + pgpl_mutex_unlock(container_layout->mutex); +} + +uint32_t pgpl_gui_container_layout_widget_amount( + PGPL_GuiContainerLayout *container_layout) { + return pgpl_vector_get_length(container_layout->widgets); +} + +void pgpl_gui_container_layout_destroy( + PGPL_GuiContainerLayout *container_layout) { + uint32_t length = pgpl_vector_get_length(container_layout->widgets); + pgpl_mutex_lock(container_layout->mutex); + + for (uint32_t i = 0; i < length; i++) { + PGPL_GuiWidget *widget = + *(PGPL_GuiWidget **)pgpl_vector_get_index(container_layout->widgets, i); + widget->destroy(widget); + } + + pgpl_mutex_destroy(container_layout->mutex); + + pgpl_vector_destroy(container_layout->widgets); + free(container_layout); +} diff --git a/src/gui/widgets/empty.c b/src/gui/widgets/empty.c new file mode 100644 index 0000000..22a9437 --- /dev/null +++ b/src/gui/widgets/empty.c @@ -0,0 +1,59 @@ +#include +#include + +static void get_content_size(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double *width, double *height, double max_width, + double max_height) { + (void)widget; + (void)theme; + (void)max_width; + (void)max_height; + + *width = 0; + *height = 0; +} + +static void render_content(PGPL_GuiWidget *widget, PGPL_Renderer *renderer, + PGPL_GuiTheme *theme, double x, double y, + double max_width, double max_height) { + (void)widget; + (void)theme; + (void)renderer; + (void)x; + (void)y; + (void)max_width; + (void)max_height; +} + +static void event(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, PGPL_Gui *gui, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data, double x, double y, + double max_width, double max_height) { + (void)widget; + (void)theme; + (void)gui; + (void)event_type; + (void)event_data; + (void)x; + (void)y; + (void)max_width; + (void)max_height; +} + +static void destroy(PGPL_GuiWidget *widget) { + pgpl_gui_empty_widget_destroy(widget); +} + +PGPL_GuiWidget *pgpl_gui_empty_widget_create(void) { + PGPL_GuiWidget *empty_widget = calloc(1, sizeof(*empty_widget)); + empty_widget->id = "PGPL_GuiWidget"; + empty_widget->get_content_size = get_content_size; + empty_widget->render_content = render_content; + empty_widget->event = event; + empty_widget->destroy = destroy; + return empty_widget; +} + +void pgpl_gui_empty_widget_destroy(PGPL_GuiWidget *empty_widget) { + free(empty_widget); +} diff --git a/src/gui/widgets/text.c b/src/gui/widgets/text.c new file mode 100644 index 0000000..0ab6f2f --- /dev/null +++ b/src/gui/widgets/text.c @@ -0,0 +1,65 @@ +#include +#include + +static void get_content_size(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, + double *width, double *height, double max_width, + double max_height) { + PGPL_GuiTextWidget *text_widget = (PGPL_GuiTextWidget *)widget; + PGPL_Rectangle rect; + + (void)max_width; + (void)max_height; + + pgpl_font_string_dimensions(theme->font, text_widget->text, + theme->font_size[widget->font_size], &rect); + + *width = rect.right - rect.left; + *height = rect.bottom - rect.top; +} + +static void render_content(PGPL_GuiWidget *widget, PGPL_Renderer *renderer, + PGPL_GuiTheme *theme, double x, double y, + double max_width, double max_height) { + PGPL_GuiTextWidget *text_widget = (PGPL_GuiTextWidget *)widget; + + (void)max_width; + (void)max_height; + + pgpl_font_render_string(renderer, theme->font, text_widget->text, + theme->text_color[widget->gui_color], x, y, + theme->font_size[widget->font_size]); +} + +static void event(PGPL_GuiWidget *widget, PGPL_GuiTheme *theme, PGPL_Gui *gui, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data, double x, double y, + double max_width, double max_height) { + (void)widget; + (void)theme; + (void)gui; + (void)event_type; + (void)event_data; + (void)x; + (void)y; + (void)max_width; + (void)max_height; +} + +static void destroy(PGPL_GuiWidget *widget) { + pgpl_gui_text_widget_destroy((PGPL_GuiTextWidget *)widget); +} + +PGPL_GuiTextWidget *pgpl_gui_text_widget_create(const char *text) { + PGPL_GuiTextWidget *text_widget = calloc(1, sizeof(*text_widget)); + text_widget->parent.id = "PGPL_GuiTextWidget"; + text_widget->parent.get_content_size = get_content_size; + text_widget->parent.render_content = render_content; + text_widget->parent.event = event; + text_widget->parent.destroy = destroy; + text_widget->text = text; + return text_widget; +} + +void pgpl_gui_text_widget_destroy(PGPL_GuiTextWidget *text_widget) { + free(text_widget); +} diff --git a/src/pgpl.c b/src/pgpl.c new file mode 100644 index 0000000..56fda58 --- /dev/null +++ b/src/pgpl.c @@ -0,0 +1,7 @@ +#include + +PGPL_Mutex *render_lock; + +void pgpl_init(void) { render_lock = pgpl_mutex_create(); } + +void pgpl_deinit(void) { pgpl_mutex_destroy(render_lock); } diff --git a/src/render/font.c b/src/render/font.c new file mode 100644 index 0000000..6ddfb23 --- /dev/null +++ b/src/render/font.c @@ -0,0 +1,261 @@ +#include "internal.h" +#include +#include +#include +#include +#include + +#define STB_TRUETYPE_IMPLEMENTATION +#define STBTT_STATIC +#include + +#ifdef __WIN32__ +#include +#endif + +#define CHAR_AMOUNT 256 +#define BANK_AMOUNT 256 + +typedef struct PGPL_FontBank { + stbtt_bakedchar baked[CHAR_AMOUNT]; + uint8_t *bitmap; + PGPL_Texture *texture; +} PGPL_FontBank; + +struct PGPL_Font { + PGPL_FontBank *banks[BANK_AMOUNT]; + uint32_t glyph_size; + uint32_t chars_horiontal; + uint32_t chars_vertical; + uint8_t *data; +}; + +/* Converts a string to a wide string, don't forget to call free() on the + * returned pointer. */ +static wchar_t *str_to_wstr(const char *str) { + size_t length = strlen(str); + wchar_t *wstr = malloc((length + 1) * sizeof(*wstr)); + + setlocale(LC_ALL, "en_US.UTF-8"); + + /* mbstowcs works just fine with UTF-8 strings on most platforms, except on + * Windows, where we have to use MultiByteToWideChar to do the exact same + * thing. */ +#if defined(__WIN32__) + MultiByteToWideChar(CP_UTF8, MB_PRECOMPOSED, str, -1, wstr, length + 1); +#else + mbstowcs(wstr, str, length + 1); +#endif + + return wstr; +} + +PGPL_Font *pgpl_font_create_from_file(const char *filename, + uint32_t glyph_size) { + PGPL_Font *font; + FILE *font_file = fopen(filename, "r"); + uint32_t size; + uint8_t *font_data; + + if (font_file == NULL) { + perror("Failed to open font"); + return NULL; + } + + fseek(font_file, 0, SEEK_END); + size = ftell(font_file); + font_data = malloc(size); + rewind(font_file); + fread(font_data, size, 1, font_file); + font = pgpl_font_create(font_data, glyph_size); + + fclose(font_file); + + return font; +} + +void pgpl_font_internal_bake(PGPL_Font *font, uint32_t index) { + font->banks[index] = malloc(sizeof(*font->banks[index])); + + font->banks[index]->bitmap = + malloc(CHAR_AMOUNT * font->glyph_size * font->glyph_size); + + stbtt_BakeFontBitmap( + font->data, 0, font->glyph_size, font->banks[index]->bitmap, + font->glyph_size * font->chars_horiontal, + font->glyph_size * font->chars_vertical, CHAR_AMOUNT * index, CHAR_AMOUNT, + font->banks[index]->baked); +} + +PGPL_Font *pgpl_font_create(uint8_t *data, uint32_t glyph_size) { + PGPL_Font *font = malloc(sizeof(*font)); + + for (uint32_t i = 0; i < BANK_AMOUNT; i++) { + font->banks[i] = NULL; + } + + font->glyph_size = glyph_size; + font->chars_vertical = 8; + font->chars_horiontal = CHAR_AMOUNT / font->chars_vertical; + font->data = data; + + return font; +} + +void pgpl_font_destroy(PGPL_Renderer *renderer, PGPL_Font *font) { + for (uint32_t i = 0; i < BANK_AMOUNT; i++) { + if (font->banks[i] != NULL) { + pgpl_render_destroy_texture(renderer, font->banks[i]->texture); + free(font->banks[i]); + } + } + free(font->data); + free(font); +} + +void pgpl_font_render_glyph(PGPL_Renderer *renderer, PGPL_Font *font, wchar_t c, + PGPL_Color color, double x, double y, double size, + double *xoff, double *yoff) { + stbtt_aligned_quad q; + uint32_t bank_index = c / 256; + uint32_t bank_offset = c % 256; + double factor = size / font->glyph_size; + float xoff_stb = *xoff; + float yoff_stb = *yoff; + + if (font->banks[bank_index] == NULL) { + pgpl_font_internal_bake(font, bank_index); + } + + if (font->banks[bank_index]->bitmap != NULL) { + font->banks[bank_index]->texture = pgpl_render_create_texture( + renderer, font->banks[bank_index]->bitmap, + font->glyph_size * font->chars_horiontal, + font->glyph_size * font->chars_vertical, PGPL_TEXTURE_FILTER_LINEAR, + PGPL_TEXTURE_FORMAT_BW); + + free(font->banks[bank_index]->bitmap); + font->banks[bank_index]->bitmap = NULL; + } + + stbtt_GetBakedQuad(font->banks[bank_index]->baked, + font->glyph_size * font->chars_horiontal, + font->glyph_size * font->chars_vertical, bank_offset, + &xoff_stb, &yoff_stb, &q, 0); + + pgpl_render_texture_extended( + renderer, font->banks[bank_index]->texture, (x + q.x0 * factor), + (y + q.y0 * factor + size / 1.75), (q.x1 - q.x0) * factor, + (q.y1 - q.y0) * factor, color, q.s0, q.t0, q.s1, q.t1); + + *xoff = xoff_stb; + *yoff = yoff_stb; +} + +/* This renders some text, also converts it to a wide string so that it + * supports Unicode characters when rendering. + */ +void pgpl_font_render_string(PGPL_Renderer *renderer, PGPL_Font *font, + const char *str, PGPL_Color color, double x, + double y, double size) { + wchar_t *wstr = str_to_wstr(str); + + pgpl_font_render_wstring(renderer, font, wstr, color, x, y, size); + + free(wstr); +} + +void pgpl_font_render_wstring(PGPL_Renderer *renderer, PGPL_Font *font, + wchar_t *str, PGPL_Color color, double x, + double y, double size) { + double xoff = 0; + double yoff = 0; + + for (uint32_t i = 0; str[i] != '\0'; i++) { + if (str[i] == '\n') { + xoff = 0; + y += size; + continue; + } + + pgpl_font_render_glyph(renderer, font, str[i], color, x, y, size, &xoff, + &yoff); + } +} + +/* Calculates the glyph coordinates, and returns them in the passed pointers. */ +void pgpl_font_glyph_dimensions(PGPL_Font *font, wchar_t c, double size, + double *xoff, double *yoff, + PGPL_Rectangle *rectangle) { + stbtt_aligned_quad q; + uint32_t bank_index = c / 256; + uint32_t bank_offset = c % 256; + double factor = size / font->glyph_size; + float xoff_stb = *xoff; + float yoff_stb = *yoff; + + if (font->banks[bank_index] == NULL) { + pgpl_font_internal_bake(font, bank_index); + } + + stbtt_GetBakedQuad(font->banks[bank_index]->baked, + font->glyph_size * font->chars_horiontal, + font->glyph_size * font->chars_vertical, bank_offset, + &xoff_stb, &yoff_stb, &q, 0); + + rectangle->top = q.y0 * factor + size / 1.5; + rectangle->left = q.x0 * factor; + rectangle->bottom = q.y1 * factor + size / 1.5; + rectangle->right = q.x1 * factor; + + *xoff = xoff_stb; + *yoff = yoff_stb; +} + +/* Calculates the coordinates of an entire string. Also returns them in the + * passed pointers. + */ +void pgpl_font_string_dimensions(PGPL_Font *font, const char *str, double size, + PGPL_Rectangle *rectangle) { + wchar_t *wstr = str_to_wstr(str); + + pgpl_font_wstring_dimensions(font, wstr, size, rectangle); + + free(wstr); +} + +void pgpl_font_wstring_dimensions(PGPL_Font *font, wchar_t *str, double size, + PGPL_Rectangle *rectangle) { + double xoff = 0; + double yoff = 0; + + rectangle->top = DBL_MAX; + rectangle->left = DBL_MAX; + rectangle->bottom = DBL_MIN; + rectangle->right = DBL_MIN; + + for (uint32_t i = 0; str[i] != '\0'; i++) { + PGPL_Rectangle glyph_rectangle = {0, 0, 0, 0}; + + if (str[i] == '\n') { + xoff = 0; + yoff += size; + continue; + } + + pgpl_font_glyph_dimensions(font, str[i], size, &xoff, &yoff, rectangle); + + if (glyph_rectangle.top < rectangle->top) { + rectangle->top = glyph_rectangle.top; + } + if (glyph_rectangle.bottom > rectangle->bottom) { + rectangle->bottom = glyph_rectangle.bottom; + } + if (glyph_rectangle.left < rectangle->left) { + rectangle->left = glyph_rectangle.left; + } + if (glyph_rectangle.right > rectangle->right) { + rectangle->right = glyph_rectangle.right; + } + } +} diff --git a/src/render/internal.h b/src/render/internal.h new file mode 100644 index 0000000..eca7af3 --- /dev/null +++ b/src/render/internal.h @@ -0,0 +1,15 @@ +#include +#include + +/* General Notes: All of the gl_* variables are translated from pixels to the + * range [-1.0, 1.0] so that they can be rendered with OpenGL. + * + * It's also important to note that this file should be platform independent, + * this code should be able to run on all OpenGL supporting devices. + */ + +#define PI 3.1415926535897932384626433 + +struct PGPL_Texture { + GLuint id; +}; diff --git a/src/render/shapes.c b/src/render/shapes.c new file mode 100644 index 0000000..f240722 --- /dev/null +++ b/src/render/shapes.c @@ -0,0 +1,96 @@ +#include "internal.h" +#include + +void pgpl_render_rectangle(PGPL_Renderer *renderer, PGPL_Color color, double x, + double y, double width, double height) { + double gl_x = x / renderer->width; + double gl_y = y / renderer->height; + double gl_width = width / renderer->width; + double gl_height = height / renderer->height; + + glColor4ub(pgpl_color_get_red(color), pgpl_color_get_green(color), + pgpl_color_get_blue(color), pgpl_color_get_alpha(color)); + + glBegin(GL_QUADS); + glVertex2d(gl_x, gl_y); + glVertex2d(gl_x + gl_width, gl_y); + glVertex2d(gl_x + gl_width, gl_y + gl_height); + glVertex2d(gl_x, gl_y + gl_height); + glEnd(); +} + +void pgpl_render_line(PGPL_Renderer *renderer, PGPL_Color color, double x0, + double y0, double x1, double y1) { + double gl_x0 = x0 / renderer->width; + double gl_y0 = y0 / renderer->height; + double gl_x1 = x1 / renderer->width; + double gl_y1 = y1 / renderer->height; + + glColor4ub(pgpl_color_get_red(color), pgpl_color_get_green(color), + pgpl_color_get_blue(color), pgpl_color_get_alpha(color)); + + glBegin(GL_LINES); + glVertex2d(gl_x0, gl_y0); + glVertex2d(gl_x1, gl_y1); + glEnd(); +} + +void pgpl_render_circle(PGPL_Renderer *renderer, PGPL_Color color, double x, + double y, double radius, double triangle_amount) { + GLfloat two_pi = 2 * PI; + double gl_x, gl_y; + + x += radius; + y += radius; + + gl_x = x / renderer->width; + gl_y = y / renderer->height; + + glColor4ub(pgpl_color_get_red(color), pgpl_color_get_green(color), + pgpl_color_get_blue(color), pgpl_color_get_alpha(color)); + + glBegin(GL_TRIANGLE_FAN); + glVertex2d(gl_x, gl_y); + for (uint32_t i = 0; i <= triangle_amount; i++) { + gl_x = (x + (radius * cos(i * two_pi / triangle_amount))) / renderer->width; + + gl_y = + (y + (radius * sin(i * two_pi / triangle_amount))) / renderer->height; + + glVertex2d(gl_x, gl_y); + } + glEnd(); +} + +void pgpl_render_point(PGPL_Renderer *renderer, PGPL_Color color, double x, + double y) { + double gl_x = x / renderer->width; + double gl_y = y / renderer->height; + + glColor4ub(pgpl_color_get_red(color), pgpl_color_get_green(color), + pgpl_color_get_blue(color), pgpl_color_get_alpha(color)); + + glBegin(GL_POINTS); + glVertex2d(gl_x, gl_y); + glEnd(); +} + +void pgpl_render_triangle(PGPL_Renderer *renderer, PGPL_Color color, double ax, + double ay, double bx, double by, double cx, + double cy) { + double gl_ax = ax / renderer->width; + double gl_ay = ay / renderer->height; + double gl_bx = bx / renderer->width; + double gl_by = by / renderer->height; + double gl_cx = cx / renderer->width; + double gl_cy = cy / renderer->height; + + glColor4ub(pgpl_color_get_red(color), pgpl_color_get_green(color), + pgpl_color_get_blue(color), pgpl_color_get_alpha(color)); + + glBegin(GL_TRIANGLES); + glVertex2d(gl_ax, gl_ay); + glVertex2d(gl_bx, gl_by); + glVertex2d(gl_cx, gl_cy); + glEnd(); +} diff --git a/src/render/texture.c b/src/render/texture.c new file mode 100644 index 0000000..9a8684f --- /dev/null +++ b/src/render/texture.c @@ -0,0 +1,143 @@ +#include "internal.h" +#include +#include + +#define STB_IMAGE_IMPLEMENTATION +#define STB_IMAGE_STATIC +#include + +PGPL_Texture * +pgpl_render_create_texture_file_memory(PGPL_Renderer *renderer, + const uint8_t *file_data, uint32_t len, + PGPL_TextureFilter filter) { + int32_t x, y, comp; + stbi_uc *data = + stbi_load_from_memory(file_data, len, &x, &y, &comp, STBI_rgb_alpha); + PGPL_Texture *texture; + + if (data != NULL) { + texture = pgpl_render_create_texture(renderer, data, x, y, filter, + PGPL_TEXTURE_FORMAT_RGBA); + } else { + fprintf(stderr, "Failed to open image: %s\n", stbi_failure_reason()); + return NULL; + } + + stbi_image_free(data); + return texture; +} + +PGPL_Texture *pgpl_render_create_texture_file(PGPL_Renderer *renderer, + const char *filename, + PGPL_TextureFilter filter) { + int32_t x, y, comp; + stbi_uc *data = stbi_load(filename, &x, &y, &comp, STBI_rgb_alpha); + PGPL_Texture *texture; + + if (data != NULL) { + texture = pgpl_render_create_texture(renderer, data, x, y, filter, + PGPL_TEXTURE_FORMAT_RGBA); + } else { + fprintf(stderr, "Failed to open image: %s\n", stbi_failure_reason()); + return NULL; + } + + stbi_image_free(data); + return texture; +} + +/* Creates an OpenGL Texture. The filterers and format are specified with a + * switch case. */ +PGPL_Texture *pgpl_render_create_texture(PGPL_Renderer *renderer, + const uint8_t *data, uint32_t width, + uint32_t height, + PGPL_TextureFilter filter, + PGPL_TextureFormat format) { + PGPL_Texture *texture = malloc(sizeof(*texture)); + int32_t gl_filter = 0; + int32_t gl_format = 0; + + (void)renderer; + + switch (filter) { + case PGPL_TEXTURE_FILTER_LINEAR: + gl_filter = GL_LINEAR; + break; + case PGPL_TEXTURE_FILTER_NEAREST: + gl_filter = GL_NEAREST; + break; + } + + switch (format) { + case PGPL_TEXTURE_FORMAT_RGBA: + gl_format = GL_RGBA; + break; + case PGPL_TEXTURE_FORMAT_RGB: + gl_format = GL_RGB; + break; + case PGPL_TEXTURE_FORMAT_BW: + gl_format = GL_ALPHA; + break; + } + + glGenTextures(1, &texture->id); + + glBindTexture(GL_TEXTURE_2D, texture->id); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter); + + glTexImage2D(GL_TEXTURE_2D, 0, gl_format, width, height, 0, gl_format, + GL_UNSIGNED_BYTE, data); + + glBindTexture(GL_TEXTURE_2D, 0); + + return texture; +} + +/* Null check so that it can be freed in the case of it being impossible to get + * another renderer + */ +void pgpl_render_destroy_texture(PGPL_Renderer *renderer, + PGPL_Texture *texture) { + if (renderer != NULL) { + glDeleteTextures(1, &texture->id); + } + free(texture); +} + +void pgpl_render_texture(PGPL_Renderer *renderer, PGPL_Texture *texture, + double x, double y, double width, double height) { + pgpl_render_texture_extended(renderer, texture, x, y, width, height, 0xFFFFFF, + 0.0f, 0.0f, 1.0f, 1.0f); +} + +void pgpl_render_texture_extended(PGPL_Renderer *renderer, + PGPL_Texture *texture, double x, double y, + double width, double height, PGPL_Color color, + double s0, double t0, double s1, double t1) { + double gl_x = x / renderer->width; + double gl_y = y / renderer->height; + double gl_width = width / renderer->width; + double gl_height = height / renderer->height; + + glBindTexture(GL_TEXTURE_2D, texture->id); + + glColor4ub(pgpl_color_get_red(color), pgpl_color_get_green(color), + pgpl_color_get_blue(color), pgpl_color_get_alpha(color)); + + glBegin(GL_QUADS); + glTexCoord2d(s0, t0); + glVertex2d(gl_x, gl_y); + glTexCoord2d(s1, t0); + glVertex2d(gl_x + gl_width, gl_y); + glTexCoord2d(s1, t1); + glVertex2d(gl_x + gl_width, gl_y + gl_height); + glTexCoord2d(s0, t1); + glVertex2d(gl_x, gl_y + gl_height); + glEnd(); + + glBindTexture(GL_TEXTURE_2D, 0); +} diff --git a/src/thread.c b/src/thread.c new file mode 100644 index 0000000..992c123 --- /dev/null +++ b/src/thread.c @@ -0,0 +1,44 @@ +#include +#include +#include + +struct PGPL_Thread { + pthread_t thread; +}; + +struct PGPL_Mutex { + pthread_mutex_t mutex; +}; + +PGPL_Thread *pgpl_thread_create(void *(*function)(void *arg), void *arg) { + PGPL_Thread *thread = malloc(sizeof(*thread)); + pthread_create(&thread->thread, NULL, function, arg); + return thread; +} + +void pgpl_thread_destroy(PGPL_Thread *thread) { free(thread); } + +void pgpl_thread_join(PGPL_Thread *thread) { + pthread_join(thread->thread, NULL); +} + +PGPL_Mutex *pgpl_mutex_create(void) { + PGPL_Mutex *mutex = malloc(sizeof(*mutex)); + pthread_mutex_init(&mutex->mutex, NULL); + return mutex; +} + +void pgpl_mutex_destroy(PGPL_Mutex *mutex) { + pthread_mutex_destroy(&mutex->mutex); + free(mutex); +} + +void pgpl_mutex_lock(PGPL_Mutex *mutex) { pthread_mutex_lock(&mutex->mutex); } + +bool pgpl_mutex_try_lock(PGPL_Mutex *mutex) { + return pthread_mutex_trylock(&mutex->mutex) == 0; +} + +void pgpl_mutex_unlock(PGPL_Mutex *mutex) { + pthread_mutex_unlock(&mutex->mutex); +} diff --git a/src/timer.c b/src/timer.c new file mode 100644 index 0000000..a100793 --- /dev/null +++ b/src/timer.c @@ -0,0 +1,48 @@ +/* _DEFAULT_SOURCE must be defined for usleep to be declared on C99 (glibc). */ +#define _DEFAULT_SOURCE +/* _XPG4_2 must be defined on OpenIndiana for usleep to be defined. */ +#define _XPG4_2 + +#include +#include +#include + +#ifdef __WIN32__ +#include +#else +#include +#endif + +struct PGPL_Timer { + clock_t time; +}; + +PGPL_Timer *pgpl_timer_create(void) { + PGPL_Timer *timer = malloc(sizeof(PGPL_Timer)); + timer->time = clock() / (CLOCKS_PER_SEC / 1000.0); + return timer; +} + +void pgpl_timer_destroy(PGPL_Timer *timer) { free(timer); } + +uint32_t pgpl_timer_get_delta(PGPL_Timer *timer) { + clock_t new_time = clock() / (CLOCKS_PER_SEC / 1000.0); + clock_t delta; + if (timer->time != 0) { + delta = new_time / timer->time; + } else { + delta = 0; + } + timer->time = new_time; + return delta; +} + +void pgpl_timer_sleep(uint32_t milliseconds) { + if (milliseconds > 0) { +#ifdef __WIN32__ + Sleep(milliseconds); +#else + usleep(1000 * milliseconds); +#endif + } +} diff --git a/src/vector.c b/src/vector.c new file mode 100644 index 0000000..82bd100 --- /dev/null +++ b/src/vector.c @@ -0,0 +1,105 @@ +#include +#include +#include + +/* TODO: Further test this file. */ + +struct PGPL_Vector { + void *data; + uint32_t data_size; + uint32_t length; + uint32_t allocated; + void *last_delete; +}; + +#define pgpl_vector_internal_conditional_resize(vector) \ + if (vector->length > vector->allocated) { \ + vector->allocated *= 2; \ + vector->data = \ + realloc(vector->data, vector->allocated * vector->data_size); \ + } + +#define pgpl_vector_internal_memcpy_offset(vector, i) \ + (char *)vector->data + (vector->data_size * (i)) + +PGPL_Vector *pgpl_vector_create(uint32_t data_size) { + PGPL_Vector *vector = malloc(sizeof(*vector)); + vector->data_size = data_size; + vector->allocated = 1; + vector->length = 0; + vector->last_delete = malloc(vector->data_size); + vector->data = malloc(vector->allocated * vector->data_size); + return vector; +} + +void pgpl_vector_destroy(PGPL_Vector *vector) { + free(vector->data); + free(vector->last_delete); + free(vector); +} + +void pgpl_vector_push_back(PGPL_Vector *vector, void *data) { + vector->length++; + pgpl_vector_internal_conditional_resize(vector); + memcpy(pgpl_vector_internal_memcpy_offset(vector, vector->length - 1), data, + vector->data_size); +} + +void pgpl_vector_push_front(PGPL_Vector *vector, void *data) { + vector->length++; + pgpl_vector_internal_conditional_resize(vector); + memmove(pgpl_vector_internal_memcpy_offset(vector, 1), vector->data, + vector->data_size * vector->length); + memcpy(vector->data, data, vector->data_size); +} + +void *pgpl_vector_pop_back(PGPL_Vector *vector) { + memcpy(vector->last_delete, + pgpl_vector_internal_memcpy_offset(vector, vector->length - 1), + vector->data_size); + + vector->length--; + + return vector->last_delete; +} + +void *pgpl_vector_pop_front(PGPL_Vector *vector) { + memcpy(vector->last_delete, vector->data, vector->data_size); + vector->length--; + memmove(vector->data, pgpl_vector_internal_memcpy_offset(vector, 1), + vector->data_size * vector->length); + return vector->last_delete; +} + +void *pgpl_vector_peek_back(PGPL_Vector *vector) { + return pgpl_vector_internal_memcpy_offset(vector, vector->length - 1); +} + +void *pgpl_vector_peek_front(PGPL_Vector *vector) { return vector->data; } + +void *pgpl_vector_delete_index(PGPL_Vector *vector, uint32_t index) { + memcpy(vector->last_delete, pgpl_vector_internal_memcpy_offset(vector, index), + vector->data_size); + memmove(pgpl_vector_internal_memcpy_offset(vector, index), + pgpl_vector_internal_memcpy_offset(vector, index + 1), + vector->data_size * (vector->length - index - 1)); + vector->length--; + return vector->last_delete; +} + +void pgpl_vector_insert_after_index(PGPL_Vector *vector, uint32_t index, + void *data) { + vector->length++; + pgpl_vector_internal_conditional_resize(vector); + memmove(pgpl_vector_internal_memcpy_offset(vector, index + 2), + pgpl_vector_internal_memcpy_offset(vector, index + 1), + vector->data_size * (vector->length - index - 2)); + memcpy(pgpl_vector_internal_memcpy_offset(vector, index + 1), data, + vector->data_size); +} + +void *pgpl_vector_get_index(PGPL_Vector *vector, uint32_t index) { + return pgpl_vector_internal_memcpy_offset(vector, index); +} + +uint32_t pgpl_vector_get_length(PGPL_Vector *vector) { return vector->length; } diff --git a/src/window/internal.h b/src/window/internal.h new file mode 100644 index 0000000..6b86e43 --- /dev/null +++ b/src/window/internal.h @@ -0,0 +1,24 @@ +#ifndef PGPL_WINDOW_INTERNAL_H +#define PGPL_WINDOW_INTERNAL_H + +#include + +/* This is needed if there are multiple windows open. Created by pgpl_init, + * destroyed by pgpl_deinit. */ +extern PGPL_Mutex *render_lock; + +typedef struct PGPL_WindowShared { + double scale; + PGPL_Vector *event_types; + PGPL_Vector *event_data; +} PGPL_WindowShared; + +PGPL_WindowEventType +pgpl_window_internal_fetch_window_event(PGPL_Window *window, + PGPL_WindowEventData *event_data); + +void pgpl_window_internal_start_render(PGPL_Window *window); + +void pgpl_window_internal_finish_render(PGPL_Window *window); + +#endif diff --git a/src/window/thread.c b/src/window/thread.c new file mode 100644 index 0000000..fd26005 --- /dev/null +++ b/src/window/thread.c @@ -0,0 +1,363 @@ +#include "internal.h" +#include +#include +#include +#include + +typedef enum PGPL_WindowThreadAction { + PGPL_WINDOW_THREAD_NONE, + PGPL_WINDOW_THREAD_DESTROY, + PGPL_WINDOW_THREAD_SHOW, + PGPL_WINDOW_THREAD_HIDE, + PGPL_WINDOW_THREAD_SET_TITLE, + PGPL_WINDOW_THREAD_GET_TITLE, + PGPL_WINDOW_THREAD_SET_SIZE, + PGPL_WINDOW_THREAD_GET_SIZE, + PGPL_WINDOW_THREAD_SET_POSITION, + PGPL_WINDOW_THREAD_GET_POSITION, + PGPL_WINDOW_THREAD_SET_SCALE, + PGPL_WINDOW_THREAD_GET_SCALE, + PGPL_WINDOW_THREAD_SET_TRANSIENT, + PGPL_WINDOW_THREAD_REPARENT, + PGPL_WINDOW_THREAD_GET_RAW_WINDOW, + PGPL_WINDOW_THREAD_CREATE_EVENT +} PGPL_WindowThreadAction; + +typedef struct PGPL_WindowThreadCreateParameters { + PGPL_WindowThread *window_thread; + const char *title; + uint32_t width, height; + int32_t x, y; +} PGPL_WindowThreadCreateParameters; + +typedef union PGPL_WindowThreadActionData { + struct { + uint32_t width; + uint32_t height; + } size_data; + struct { + int32_t x; + int32_t y; + } position_data; + const char *title; + double scale; + void *raw_window; + struct { + PGPL_WindowEventType type; + PGPL_WindowEventData *data; + } event; +} PGPL_WindowThreadActionData; + +struct PGPL_WindowThread { + PGPL_Window *window; + PGPL_Thread *thread; + PGPL_Mutex *action_lock; + PGPL_Mutex *process_ready_lock; + PGPL_Mutex *result_ready_lock; + PGPL_WindowThreadAction action; + PGPL_WindowThreadActionData data; + bool (*event_loop)(PGPL_Window *window, PGPL_WindowEventType event, + PGPL_WindowEventData *event_data, void *user_data); + void *user_data; +}; + +/* This is the main event_loop for the threads. It fetches the Window events and + * calls the event loop callback. It also receives other events from the + * functions later in this file. + * + * TODO: Allow choosing the framerate. + */ +static void *pgpl_window_event_loop(void *arg) { + PGPL_WindowThreadCreateParameters *args = arg; + PGPL_WindowThread *window_thread = args->window_thread; + PGPL_Timer *timer; + + bool running = true; + + window_thread->window = pgpl_window_create(args->title, args->width, + args->height, args->x, args->y); + + free(arg); + + pgpl_mutex_unlock(window_thread->action_lock); + + timer = pgpl_timer_create(); + while (running) { + PGPL_WindowEventData event_data; + + while (running) { + PGPL_WindowEventType event_type = + pgpl_window_fetch_event(window_thread->window, &event_data); + + bool lock_status = pgpl_mutex_try_lock(window_thread->process_ready_lock); + + if (lock_status != true && event_type == PGPL_WINDOW_EVENT_NONE) { + break; + } + + if (event_type != PGPL_WINDOW_EVENT_NONE) { + if (!window_thread->event_loop(window_thread->window, event_type, + &event_data, window_thread->user_data)) { + running = false; + } + } + + if (lock_status == true) { + switch (window_thread->action) { + case PGPL_WINDOW_THREAD_NONE: + break; + case PGPL_WINDOW_THREAD_DESTROY: + window_thread->event_loop(window_thread->window, + PGPL_WINDOW_EVENT_CLOSE, &event_data, + window_thread->user_data); + running = 0; + break; + case PGPL_WINDOW_THREAD_SHOW: + pgpl_window_show(window_thread->window); + break; + case PGPL_WINDOW_THREAD_HIDE: + pgpl_window_hide(window_thread->window); + break; + case PGPL_WINDOW_THREAD_SET_TITLE: + pgpl_window_set_title(window_thread->window, + window_thread->data.title); + break; + case PGPL_WINDOW_THREAD_GET_TITLE: + window_thread->data.title = + pgpl_window_get_title(window_thread->window); + break; + case PGPL_WINDOW_THREAD_SET_SIZE: + pgpl_window_set_size(window_thread->window, + window_thread->data.size_data.width, + window_thread->data.size_data.height); + break; + case PGPL_WINDOW_THREAD_GET_SIZE: + pgpl_window_get_size(window_thread->window, + &window_thread->data.size_data.width, + &window_thread->data.size_data.height); + break; + case PGPL_WINDOW_THREAD_SET_POSITION: + pgpl_window_set_position(window_thread->window, + window_thread->data.position_data.x, + window_thread->data.position_data.y); + break; + case PGPL_WINDOW_THREAD_GET_POSITION: + pgpl_window_get_position(window_thread->window, + &window_thread->data.position_data.x, + &window_thread->data.position_data.y); + break; + case PGPL_WINDOW_THREAD_SET_SCALE: + pgpl_window_set_scale(window_thread->window, + window_thread->data.scale); + break; + case PGPL_WINDOW_THREAD_GET_SCALE: + window_thread->data.scale = + pgpl_window_get_scale(window_thread->window); + break; + case PGPL_WINDOW_THREAD_SET_TRANSIENT: + pgpl_window_set_transient(window_thread->window, + window_thread->data.raw_window); + break; + case PGPL_WINDOW_THREAD_REPARENT: + pgpl_window_reparent_to(window_thread->window, + window_thread->data.raw_window); + break; + case PGPL_WINDOW_THREAD_GET_RAW_WINDOW: + window_thread->data.raw_window = + pgpl_window_get_raw_window(window_thread->window); + break; + case PGPL_WINDOW_THREAD_CREATE_EVENT: + pgpl_window_create_event(window_thread->window, + window_thread->data.event.type, + window_thread->data.event.data); + break; + } + pgpl_mutex_unlock(window_thread->result_ready_lock); + } + } + + pgpl_window_create_event(window_thread->window, + PGPL_WINDOW_EVENT_RENDER_REQUEST, NULL); + pgpl_timer_sleep(20 - pgpl_timer_get_delta(timer)); + } + + pgpl_timer_destroy(timer); + pgpl_window_destroy(window_thread->window); + + pgpl_mutex_destroy(window_thread->action_lock); + pgpl_mutex_destroy(window_thread->process_ready_lock); + pgpl_mutex_destroy(window_thread->result_ready_lock); + + pgpl_thread_destroy(window_thread->thread); + + free(window_thread); + return NULL; +} + +/* Creates all needed mutexes. */ +PGPL_WindowThread *pgpl_window_thread_create( + const char *title, uint32_t width, uint32_t height, int32_t x, int32_t y, + bool (*event_loop)(PGPL_Window *window, PGPL_WindowEventType event, + PGPL_WindowEventData *event_data, void *user_data), + void *user_data) { + PGPL_WindowThreadCreateParameters *args = malloc(sizeof(*args)); + + args->window_thread = malloc(sizeof(*args->window_thread)); + args->window_thread->user_data = user_data; + args->window_thread->event_loop = event_loop; + args->window_thread->action = PGPL_WINDOW_THREAD_NONE; + args->title = title; + args->width = width; + args->height = height; + args->x = x; + args->y = y; + + args->window_thread->action_lock = pgpl_mutex_create(); + args->window_thread->process_ready_lock = pgpl_mutex_create(); + args->window_thread->result_ready_lock = pgpl_mutex_create(); + + pgpl_mutex_lock(args->window_thread->action_lock); + pgpl_mutex_lock(args->window_thread->process_ready_lock); + pgpl_mutex_lock(args->window_thread->result_ready_lock); + + args->window_thread->thread = + pgpl_thread_create(pgpl_window_event_loop, args); + + return args->window_thread; +} + +PGPL_WindowThreadActionData * +pgpl_window_thread_internal_send_message(PGPL_WindowThread *window_thread, + PGPL_WindowThreadAction action, + PGPL_WindowThreadActionData *data) { + pgpl_mutex_lock(window_thread->action_lock); + window_thread->action = action; + if (data != NULL) { + window_thread->data = *data; + } + pgpl_mutex_unlock(window_thread->process_ready_lock); + pgpl_mutex_lock(window_thread->result_ready_lock); + if (data != NULL) { + *data = window_thread->data; + } + pgpl_mutex_unlock(window_thread->action_lock); + return data; +} + +void pgpl_window_thread_destroy(PGPL_WindowThread *window_thread) { + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_DESTROY, NULL); +} + +void pgpl_window_thread_show(PGPL_WindowThread *window_thread) { + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_SHOW, NULL); +} + +void pgpl_window_thread_hide(PGPL_WindowThread *window_thread) { + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_HIDE, NULL); +} + +void pgpl_window_thread_set_title(PGPL_WindowThread *window_thread, + const char *title) { + PGPL_WindowThreadActionData data; + data.title = title; + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_SET_TITLE, &data); +} + +const char *pgpl_window_thread_get_title(PGPL_WindowThread *window_thread) { + PGPL_WindowThreadActionData data; + return pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_GET_TITLE, &data) + ->title; +} + +void pgpl_window_thread_get_size(PGPL_WindowThread *window_thread, + uint32_t *width, uint32_t *height) { + PGPL_WindowThreadActionData data; + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_GET_SIZE, &data); + *width = data.size_data.width; + *height = data.size_data.height; +} + +void pgpl_window_thread_set_size(PGPL_WindowThread *window_thread, + uint32_t width, uint32_t height) { + PGPL_WindowThreadActionData data; + data.size_data.width = width; + data.size_data.height = height; + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_SET_SIZE, &data); +} + +void pgpl_window_thread_get_position(PGPL_WindowThread *window_thread, + int32_t *x, int32_t *y) { + PGPL_WindowThreadActionData data; + pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_GET_POSITION, &data); + *x = data.position_data.x; + *y = data.position_data.y; +} + +void pgpl_window_thread_set_position(PGPL_WindowThread *window_thread, + int32_t x, int32_t y) { + PGPL_WindowThreadActionData data; + data.position_data.x = x; + data.position_data.y = y; + pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_SET_POSITION, &data); +} + +double pgpl_window_thread_get_scale(PGPL_WindowThread *window_thread) { + PGPL_WindowThreadActionData data; + return pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_GET_SCALE, &data) + ->scale; +} + +void pgpl_window_thread_set_scale(PGPL_WindowThread *window_thread, + double scale) { + PGPL_WindowThreadActionData data; + data.scale = scale; + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_SET_SCALE, &data); +} + +void pgpl_window_thread_set_transient(PGPL_WindowThread *window_thread, + void *parent) { + PGPL_WindowThreadActionData data; + data.raw_window = parent; + pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_SET_TRANSIENT, &data); +} + +void pgpl_window_thread_reparent_to(PGPL_WindowThread *window_thread, + void *parent) { + PGPL_WindowThreadActionData data; + data.raw_window = parent; + pgpl_window_thread_internal_send_message(window_thread, + PGPL_WINDOW_THREAD_REPARENT, &data); +} + +void *pgpl_window_thread_get_raw_window(PGPL_WindowThread *window_thread) { + PGPL_WindowThreadActionData data; + return pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_GET_RAW_WINDOW, &data) + ->raw_window; +} + +void pgpl_window_thread_create_event(PGPL_WindowThread *window_thread, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data) { + PGPL_WindowThreadActionData data; + data.event.type = event_type; + data.event.data = event_data; + pgpl_window_thread_internal_send_message( + window_thread, PGPL_WINDOW_THREAD_CREATE_EVENT, &data); +} + +void pgpl_window_thread_await_destruction(PGPL_WindowThread *window_thread) { + pgpl_thread_join(window_thread->thread); +} diff --git a/src/window/window-win32.c b/src/window/window-win32.c new file mode 100644 index 0000000..d4883f0 --- /dev/null +++ b/src/window/window-win32.c @@ -0,0 +1,331 @@ +#ifdef __WIN32__ +#include "internal.h" +#include +#include +#include + +struct PGPL_Window { + PGPL_WindowShared shared; + HWND hwnd; + WNDCLASS wc; + HDC hdc; + HGLRC wgl_context; + PGPL_Mutex *window_proc_vector_lock; + PGPL_Vector *window_proc_event_type; + PGPL_Vector *window_proc_event_data; + int32_t last_mouse_x, last_mouse_y; + char title[128]; +}; + +/* Our WindowProc function, this needs to be overhauled a bit, and certain + * things in here could be solved with more macros, to clean up and shorten the + * code a bit. + */ +static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, + LPARAM lParam) { + PGPL_Window *window = (PGPL_Window *)GetWindowLongPtr(hwnd, 0); + PGPL_WindowEventType event_type; + PGPL_WindowEventData event_data; + + if (window == NULL) { + return DefWindowProc(hwnd, uMsg, wParam, lParam); + } + + pgpl_mutex_lock(window->window_proc_vector_lock); + + switch (uMsg) { + case WM_SETCURSOR: + if (LOWORD(lParam) == HTCLIENT) { + SetCursor(LoadCursor(NULL, IDC_ARROW)); + pgpl_mutex_unlock(window->window_proc_vector_lock); + return TRUE; + } else { + pgpl_mutex_unlock(window->window_proc_vector_lock); + return DefWindowProc(hwnd, uMsg, wParam, lParam); + } + break; + case WM_KEYDOWN: + event_type = PGPL_WINDOW_EVENT_KEY_PRESS; + event_data.input_event.key = wParam; + event_data.input_event.x = window->last_mouse_x; + event_data.input_event.y = window->last_mouse_y; + break; + case WM_KEYUP: + event_type = PGPL_WINDOW_EVENT_KEY_RELEASE; + event_data.input_event.key = wParam; + event_data.input_event.x = window->last_mouse_x; + event_data.input_event.y = window->last_mouse_y; + break; + case WM_LBUTTONDOWN: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_PRESS; + event_data.input_event.key = 1; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_LBUTTONUP: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_RELEASE; + event_data.input_event.key = 1; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_MBUTTONDOWN: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_PRESS; + event_data.input_event.key = 2; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_MBUTTONUP: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_RELEASE; + event_data.input_event.key = 2; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_RBUTTONDOWN: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_PRESS; + event_data.input_event.key = 3; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_RBUTTONUP: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_RELEASE; + event_data.input_event.key = 3; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_MOUSEWHEEL: { + /* TODO: This code probably doesn't work that well. Unlike X11, this only + * returns a MOUSE_PRESS event, and if the scrolls are more granular, this + * will scroll really fast. + */ + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_PRESS; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + event_data.input_event.key = GET_WHEEL_DELTA_WPARAM(wParam) > 0 ? 4 : 5; + break; + } + case WM_MOUSEMOVE: { + POINTS points = MAKEPOINTS(lParam); + event_type = PGPL_WINDOW_EVENT_MOUSE_MOVE; + window->last_mouse_x = points.x; + window->last_mouse_y = points.y; + event_data.input_event.key = -1; + event_data.input_event.x = points.x; + event_data.input_event.y = points.y; + break; + } + case WM_CLOSE: + event_type = PGPL_WINDOW_EVENT_CLOSE; + break; + default: + event_type = PGPL_WINDOW_EVENT_NONE; + pgpl_mutex_unlock(window->window_proc_vector_lock); + return DefWindowProc(hwnd, uMsg, wParam, lParam); + } + + pgpl_vector_push_back(window->window_proc_event_type, &event_type); + pgpl_vector_push_back(window->window_proc_event_data, &event_data); + pgpl_mutex_unlock(window->window_proc_vector_lock); + return 0; +} + +PGPL_Window *pgpl_window_create(const char *title, uint32_t width, + uint32_t height, int32_t x, int32_t y) { + PGPL_Window *window = malloc(sizeof(*window)); + int32_t pixel_format; + + PIXELFORMATDESCRIPTOR pfd = {sizeof(PIXELFORMATDESCRIPTOR), + 1, + PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | + PFD_DOUBLEBUFFER, + PFD_TYPE_RGBA, + 32, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24, + 8, + 0, + PFD_MAIN_PLANE, + 0, + 0, + 0, + 0}; + + /* TODO: Move into shared function? */ + window->shared.scale = 1.0; + window->shared.event_data = pgpl_vector_create(sizeof(PGPL_WindowEventData)); + window->shared.event_types = pgpl_vector_create(sizeof(PGPL_WindowEventType)); + + window->window_proc_event_data = + pgpl_vector_create(sizeof(PGPL_WindowEventData)); + window->window_proc_event_type = + pgpl_vector_create(sizeof(PGPL_WindowEventType)); + + memset(&window->wc, 0, sizeof(window->wc)); + + window->window_proc_vector_lock = pgpl_mutex_create(); + + window->wc.lpfnWndProc = WindowProc; + window->wc.cbWndExtra = sizeof(PGPL_Window *); + window->wc.lpszClassName = "PGPL_Window Window"; + window->wc.style = CS_OWNDC; + + RegisterClass(&window->wc); + + window->hwnd = + CreateWindowEx(0, window->wc.lpszClassName, title, WS_OVERLAPPEDWINDOW, x, + y, width, height, NULL, NULL, window->wc.hInstance, NULL); + + if (window->hwnd == NULL) { + return NULL; + } + + SetWindowLongPtr(window->hwnd, 0, (LONG_PTR)window); + SetWindowPos(window->hwnd, NULL, x, y, width, height, 0); + + window->hdc = GetDC(window->hwnd); + pixel_format = ChoosePixelFormat(window->hdc, &pfd); + SetPixelFormat(window->hdc, pixel_format, &pfd); + + window->wgl_context = wglCreateContext(window->hdc); + + return window; +} + +void pgpl_window_destroy(PGPL_Window *window) { + /* TODO: Also turn this into a generic function perhaps. */ + pgpl_vector_destroy(window->shared.event_data); + pgpl_vector_destroy(window->shared.event_types); + pgpl_mutex_destroy(window->window_proc_vector_lock); + wglMakeCurrent(NULL, NULL); + wglDeleteContext(window->wgl_context); + ReleaseDC(window->hwnd, window->hdc); + UnregisterClass(window->wc.lpszClassName, window->wc.hInstance); + DestroyWindow(window->hwnd); +} + +void pgpl_window_show(PGPL_Window *window) { + ShowWindow(window->hwnd, SW_SHOW); +} + +void pgpl_window_hide(PGPL_Window *window) { + ShowWindow(window->hwnd, SW_HIDE); +} + +void pgpl_window_set_title(PGPL_Window *window, const char *title) { + SetWindowText(window->hwnd, title); +} + +/* 128 is allowed as the max count, because it includes the null terminator */ +const char *pgpl_window_get_title(PGPL_Window *window) { + GetWindowText(window->hwnd, window->title, 128); + return window->title; +} + +void pgpl_window_get_size(PGPL_Window *window, uint32_t *width, + uint32_t *height) { + RECT rect; + GetClientRect(window->hwnd, &rect); + *width = rect.right - rect.left; + *height = rect.bottom - rect.top; +} + +void pgpl_window_set_size(PGPL_Window *window, uint32_t width, + uint32_t height) { + SetWindowPos(window->hwnd, NULL, 0, 0, width, height, SWP_NOMOVE); +} + +void pgpl_window_get_position(PGPL_Window *window, int32_t *x, int32_t *y) { + WINDOWPLACEMENT placement; + GetWindowPlacement(window->hwnd, &placement); + *x = placement.ptMinPosition.x; + *y = placement.ptMinPosition.y; +} + +void pgpl_window_set_position(PGPL_Window *window, int32_t x, int32_t y) { + SetWindowPos(window->hwnd, NULL, x, y, 0, 0, SWP_NOSIZE); +} + +/* Fetches an event, the mutex might be useless entirely. This basically calls + * the WindowProc, and takes it's data back out to be returned. */ +PGPL_WindowEventType +pgpl_window_internal_fetch_window_event(PGPL_Window *window, + PGPL_WindowEventData *event_data) { + MSG msg; + PGPL_WindowEventType event_type = PGPL_WINDOW_EVENT_NONE; + + if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) > 0) { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + + pgpl_mutex_lock(window->window_proc_vector_lock); + if (pgpl_vector_get_length(window->window_proc_event_type) > 0) { + event_type = *(PGPL_WindowEventType *)pgpl_vector_pop_front( + window->window_proc_event_type); + *event_data = *(PGPL_WindowEventData *)pgpl_vector_pop_front( + window->window_proc_event_data); + } + + pgpl_mutex_unlock(window->window_proc_vector_lock); + + return event_type; +} + +/* Here we reparent the window, this is because under Windows, this creates a + * subwindow of sorts on the other window, so this behaves "similarily" to the + * X11 function. */ +void pgpl_window_set_transient(PGPL_Window *window, void *parent) { + SetParent(window->hwnd, parent); +} + +/* These style changes are done to remove the borders around the window, which + * are usually undesireable in reparenting contexts, especially when working + * with audio plugins. */ +void pgpl_window_reparent_to(PGPL_Window *window, void *parent) { + LONG style = GetWindowLongPtr(window->hwnd, GWL_STYLE); + LONG ex_style = GetWindowLongPtr(window->hwnd, GWL_EXSTYLE); + style &= ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | + WS_SYSMENU); + ex_style &= ~(WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE); + SetWindowLongPtr(window->hwnd, GWL_STYLE, style); + SetWindowLongPtr(window->hwnd, GWL_EXSTYLE, ex_style); + pgpl_window_set_transient(window, parent); +} + +void *pgpl_window_get_raw_window(PGPL_Window *window) { return window->hwnd; } + +void pgpl_window_internal_start_render(PGPL_Window *window) { + pgpl_mutex_lock(render_lock); + wglMakeCurrent(window->hdc, window->wgl_context); +} + +void pgpl_window_internal_finish_render(PGPL_Window *window) { + wglSwapLayerBuffers(window->hdc, WGL_SWAP_MAIN_PLANE); + pgpl_mutex_unlock(render_lock); +} + +#endif diff --git a/src/window/window-x11.c b/src/window/window-x11.c new file mode 100644 index 0000000..ebf6928 --- /dev/null +++ b/src/window/window-x11.c @@ -0,0 +1,232 @@ +#ifdef __unix__ +#include "internal.h" +#include +#include +#include + +struct PGPL_Window { + PGPL_WindowShared shared; + Display *display; + Window window; + Atom wm_delete; + GLXContext glx_context; + char *title; + bool reparented; +}; + +/* Creates a basic X11 window with GLX. We select all the events that we handle + * in here, and create the most basic GLX context that we need. */ +PGPL_Window *pgpl_window_create(const char *title, uint32_t width, + uint32_t height, int32_t x, int32_t y) { + PGPL_Window *window = malloc(sizeof(*window)); + + int32_t screen; + Window root; + XSetWindowAttributes window_attributes; + + GLint attributes[5] = {GLX_RGBA, GLX_DOUBLEBUFFER, None}; + XVisualInfo *visual; + + window->title = NULL; + + /* TODO: Move into shared function? */ + window->shared.scale = 1.0; + window->shared.event_data = pgpl_vector_create(sizeof(PGPL_WindowEventData)); + window->shared.event_types = pgpl_vector_create(sizeof(PGPL_WindowEventType)); + + window->reparented = 0; + + window->display = XOpenDisplay(NULL); + + screen = DefaultScreen(window->display); + root = DefaultRootWindow(window->display); + + visual = glXChooseVisual(window->display, screen, attributes); + + window_attributes.colormap = + XCreateColormap(window->display, root, visual->visual, AllocNone); + window_attributes.event_mask = KeyPressMask | KeyReleaseMask | + ButtonPressMask | ButtonReleaseMask | + PointerMotionMask; + + window->window = XCreateWindow(window->display, root, x, y, width, height, 0, + visual->depth, InputOutput, visual->visual, + CWColormap | CWEventMask, &window_attributes); + + XStoreName(window->display, window->window, title); + + /* If the window gets closed by the WM, this let's us catch that and + * gracefully exit. */ + window->wm_delete = XInternAtom(window->display, "WM_DELETE_WINDOW", False); + XSetWMProtocols(window->display, window->window, &window->wm_delete, 1); + + window->glx_context = + glXCreateContext(window->display, visual, NULL, GL_TRUE); + + XFlush(window->display); + + free(visual); + + return window; +} + +void pgpl_window_destroy(PGPL_Window *window) { + /* TODO: Also turn this into a generic function perhaps. */ + pgpl_vector_destroy(window->shared.event_data); + pgpl_vector_destroy(window->shared.event_types); + if (window->title != NULL) { + XFree(window->title); + } + glXDestroyContext(window->display, window->glx_context); + /* Can cause problems when reparented, so we just don't destroy the window if + * we have been reparented. */ + if (!window->reparented) { + XDestroyWindow(window->display, window->window); + } + XCloseDisplay(window->display); + free(window); +} + +void pgpl_window_show(PGPL_Window *window) { + XMapWindow(window->display, window->window); + XFlush(window->display); +} + +void pgpl_window_hide(PGPL_Window *window) { + XUnmapWindow(window->display, window->window); + XFlush(window->display); +} + +void pgpl_window_set_title(PGPL_Window *window, const char *title) { + XStoreName(window->display, window->window, title); + XFlush(window->display); +} + +const char *pgpl_window_get_title(PGPL_Window *window) { + if (window->title != NULL) { + XFree(window->title); + } + XFetchName(window->display, window->window, &window->title); + return window->title; +} + +void pgpl_window_get_size(PGPL_Window *window, uint32_t *width, + uint32_t *height) { + XWindowAttributes attributes; + XGetWindowAttributes(window->display, window->window, &attributes); + if (width != NULL) { + *width = attributes.width; + } + if (height != NULL) { + *height = attributes.height; + } +} + +void pgpl_window_set_size(PGPL_Window *window, uint32_t width, + uint32_t height) { + XResizeWindow(window->display, window->window, width, height); + XFlush(window->display); +} + +void pgpl_window_get_position(PGPL_Window *window, int32_t *x, int32_t *y) { + XWindowAttributes attributes; + XGetWindowAttributes(window->display, window->window, &attributes); + if (x != NULL) { + *x = attributes.x; + } + if (y != NULL) { + *y = attributes.y; + } +} + +void pgpl_window_set_position(PGPL_Window *window, int32_t x, int32_t y) { + XMoveWindow(window->display, window->window, x, y); + XFlush(window->display); +} + +/* This fetches the event from X11 and translates it to our own format, returns + * an Error if the Event was unknown. + * + * TODO: Translate the keymaps */ +PGPL_WindowEventType +pgpl_window_internal_fetch_window_event(PGPL_Window *window, + PGPL_WindowEventData *event_data) { + if (XPending(window->display)) { + XEvent event; + XNextEvent(window->display, &event); + switch (event.type) { + case KeyPress: + if (event_data != NULL) { + event_data->input_event.x = event.xkey.x; + event_data->input_event.y = event.xkey.y; + event_data->input_event.key = event.xkey.keycode; + } + return PGPL_WINDOW_EVENT_KEY_PRESS; + break; + case KeyRelease: + if (event_data != NULL) { + event_data->input_event.x = event.xkey.x; + event_data->input_event.y = event.xkey.y; + event_data->input_event.key = event.xkey.keycode; + } + return PGPL_WINDOW_EVENT_KEY_RELEASE; + break; + case ButtonPress: + if (event_data != NULL) { + event_data->input_event.x = event.xbutton.x; + event_data->input_event.y = event.xbutton.y; + event_data->input_event.key = event.xbutton.button; + } + return PGPL_WINDOW_EVENT_MOUSE_PRESS; + break; + case ButtonRelease: + if (event_data != NULL) { + event_data->input_event.x = event.xbutton.x; + event_data->input_event.y = event.xbutton.y; + event_data->input_event.key = event.xbutton.button; + } + return PGPL_WINDOW_EVENT_MOUSE_RELEASE; + break; + case MotionNotify: + if (event_data != NULL) { + event_data->input_event.x = event.xbutton.x; + event_data->input_event.y = event.xbutton.y; + event_data->input_event.key = 0; + } + return PGPL_WINDOW_EVENT_MOUSE_MOVE; + break; + case ClientMessage: + if (event.xclient.data.l[0] == (long)window->wm_delete) + return PGPL_WINDOW_EVENT_CLOSE; + return PGPL_WINDOW_EVENT_ERROR; + break; + default: + return PGPL_WINDOW_EVENT_ERROR; + } + } + return PGPL_WINDOW_EVENT_NONE; +} + +void pgpl_window_set_transient(PGPL_Window *window, void *parent) { + XSetTransientForHint(window->display, window->window, *(Window *)parent); +} + +void pgpl_window_reparent_to(PGPL_Window *window, void *parent) { + XReparentWindow(window->display, window->window, *(Window *)parent, 0, 0); + window->reparented = true; +} + +void *pgpl_window_get_raw_window(PGPL_Window *window) { + return &window->window; +} + +void pgpl_window_internal_start_render(PGPL_Window *window) { + pgpl_mutex_lock(render_lock); + glXMakeCurrent(window->display, window->window, window->glx_context); +} + +void pgpl_window_internal_finish_render(PGPL_Window *window) { + glXSwapBuffers(window->display, window->window); + pgpl_mutex_unlock(render_lock); +} +#endif diff --git a/src/window/window.c b/src/window/window.c new file mode 100644 index 0000000..59634bc --- /dev/null +++ b/src/window/window.c @@ -0,0 +1,93 @@ +#include "internal.h" +#include +#include +#include + +/* Platform agnostic functions for our PGPL_Window "class" */ + +void pgpl_window_set_scale(PGPL_Window *window, double scale) { + PGPL_WindowShared *window_shared = (PGPL_WindowShared *)window; + window_shared->scale = scale; +} + +double pgpl_window_get_scale(PGPL_Window *window) { + PGPL_WindowShared *window_shared = (PGPL_WindowShared *)window; + return window_shared->scale; +} + +PGPL_WindowEventType pgpl_window_fetch_event(PGPL_Window *window, + PGPL_WindowEventData *event_data) { + PGPL_WindowShared *window_shared = (PGPL_WindowShared *)window; + PGPL_WindowEventType event_type; + + while ((event_type = pgpl_window_internal_fetch_window_event( + window, event_data)) != PGPL_WINDOW_EVENT_NONE) { + if (event_type == PGPL_WINDOW_EVENT_MOUSE_PRESS || + event_type == PGPL_WINDOW_EVENT_MOUSE_RELEASE || + event_type == PGPL_WINDOW_EVENT_KEY_PRESS || + event_type == PGPL_WINDOW_EVENT_KEY_RELEASE || + event_type == PGPL_WINDOW_EVENT_MOUSE_MOVE) { + event_data->input_event.x /= window_shared->scale; + event_data->input_event.y /= window_shared->scale; + } + pgpl_vector_push_back(window_shared->event_types, &event_type); + pgpl_vector_push_back(window_shared->event_data, event_data); + } + + if (pgpl_vector_get_length(window_shared->event_types) > 0) { + *event_data = *(PGPL_WindowEventData *)pgpl_vector_pop_front( + window_shared->event_data); + event_type = *(PGPL_WindowEventType *)pgpl_vector_pop_front( + window_shared->event_types); + return event_type; + } else { + return PGPL_WINDOW_EVENT_NONE; + } +} + +void pgpl_window_create_event(PGPL_Window *window, + PGPL_WindowEventType event_type, + PGPL_WindowEventData *event_data) { + PGPL_WindowShared *window_shared = (PGPL_WindowShared *)window; + pgpl_vector_push_back(window_shared->event_types, &event_type); + if (event_data == NULL) { + PGPL_WindowEventData data; + pgpl_vector_push_back(window_shared->event_data, &data); + } else { + pgpl_vector_push_back(window_shared->event_data, &event_data); + } +} + +/* Enables important OpenGL settings, like transparency support, and sets up our + * projection matrix to be easier to work with. */ +PGPL_Renderer *pgpl_window_start_render(PGPL_Window *window, PGPL_Color color) { + PGPL_WindowShared *window_shared = (PGPL_WindowShared *)window; + PGPL_Renderer *renderer = malloc(sizeof(*renderer)); + pgpl_window_internal_start_render(window); + + glEnable(GL_TEXTURE_2D); + glEnable(GL_BLEND); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + pgpl_window_get_size(window, &renderer->width, &renderer->height); + glViewport(0, 0, renderer->width, renderer->height); + + glPushMatrix(); + glOrtho(0.0, 1.0, 1.0, 0.0, 0.0, 1.0); + glScalef(window_shared->scale, window_shared->scale, window_shared->scale); + + glClearColor( + pgpl_color_get_red(color) / 255.0, pgpl_color_get_green(color) / 255.0, + pgpl_color_get_blue(color) / 255.0, pgpl_color_get_alpha(color) / 255.0); + glClear(GL_COLOR_BUFFER_BIT); + + return renderer; +} + +void pgpl_window_finish_render(PGPL_Window *window, PGPL_Renderer *renderer) { + glPopMatrix(); + pgpl_window_internal_finish_render(window); + free(renderer); +} diff --git a/tests/clap/all.h b/tests/clap/all.h new file mode 100644 index 0000000..1e105c4 --- /dev/null +++ b/tests/clap/all.h @@ -0,0 +1,17 @@ +#pragma once + +#include "clap.h" + +#include "factory/draft/plugin-invalidation.h" +#include "factory/draft/plugin-state-converter.h" + +#include "ext/draft/extensible-audio-ports.h" +#include "ext/draft/gain-adjustment-metering.h" +#include "ext/draft/mini-curve-display.h" +#include "ext/draft/project-location.h" +#include "ext/draft/resource-directory.h" +#include "ext/draft/scratch-memory.h" +#include "ext/draft/transport-control.h" +#include "ext/draft/triggers.h" +#include "ext/draft/tuning.h" +#include "ext/draft/undo.h" diff --git a/tests/clap/audio-buffer.h b/tests/clap/audio-buffer.h new file mode 100644 index 0000000..cd18f3a --- /dev/null +++ b/tests/clap/audio-buffer.h @@ -0,0 +1,37 @@ +#pragma once + +#include "private/std.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Sample code for reading a stereo buffer: +// +// bool isLeftConstant = (buffer->constant_mask & (1 << 0)) != 0; +// bool isRightConstant = (buffer->constant_mask & (1 << 1)) != 0; +// +// for (int i = 0; i < N; ++i) { +// float l = data32[0][isLeftConstant ? 0 : i]; +// float r = data32[1][isRightConstant ? 0 : i]; +// } +// +// Note: checking the constant mask is optional, and this implies that +// the buffer must be filled with the constant value. +// Rationale: if a buffer reader doesn't check the constant mask, then it may +// process garbage samples and in result, garbage samples may be transmitted +// to the audio interface with all the bad consequences it can have. +// +// The constant mask is a hint. +typedef struct clap_audio_buffer { + // Either data32 or data64 pointer will be set. + float **data32; + double **data64; + uint32_t channel_count; + uint32_t latency; // latency from/to the audio interface + uint64_t constant_mask; +} clap_audio_buffer_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/clap.h b/tests/clap/clap.h new file mode 100644 index 0000000..6da5676 --- /dev/null +++ b/tests/clap/clap.h @@ -0,0 +1,64 @@ +/* + * CLAP - CLever Audio Plugin + * ~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * Copyright (c) 2014...2022 Alexandre BIQUE + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#pragma once + +#include "entry.h" + +#include "factory/plugin-factory.h" +#include "factory/preset-discovery.h" + +#include "plugin.h" +#include "plugin-features.h" +#include "host.h" +#include "universal-plugin-id.h" + +#include "ext/ambisonic.h" +#include "ext/audio-ports-activation.h" +#include "ext/audio-ports-config.h" +#include "ext/audio-ports.h" +#include "ext/configurable-audio-ports.h" +#include "ext/context-menu.h" +#include "ext/event-registry.h" +#include "ext/gui.h" +#include "ext/latency.h" +#include "ext/log.h" +#include "ext/note-name.h" +#include "ext/note-ports.h" +#include "ext/param-indication.h" +#include "ext/params.h" +#include "ext/posix-fd-support.h" +#include "ext/preset-load.h" +#include "ext/remote-controls.h" +#include "ext/render.h" +#include "ext/state-context.h" +#include "ext/state.h" +#include "ext/surround.h" +#include "ext/tail.h" +#include "ext/thread-check.h" +#include "ext/thread-pool.h" +#include "ext/timer-support.h" +#include "ext/track-info.h" +#include "ext/voice-info.h" diff --git a/tests/clap/color.h b/tests/clap/color.h new file mode 100644 index 0000000..9da24fa --- /dev/null +++ b/tests/clap/color.h @@ -0,0 +1,20 @@ +#pragma once + +#include "private/std.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_color { + uint8_t alpha; + uint8_t red; + uint8_t green; + uint8_t blue; +} clap_color_t; + +static const CLAP_CONSTEXPR clap_color_t CLAP_COLOR_TRANSPARENT = { 0, 0, 0, 0 }; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/entry.h b/tests/clap/entry.h new file mode 100644 index 0000000..abb92f3 --- /dev/null +++ b/tests/clap/entry.h @@ -0,0 +1,136 @@ +#pragma once + +#include "version.h" +#include "private/macros.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// This interface is the entry point of the dynamic library. +// +// CLAP plugins standard search path: +// +// Linux +// - ~/.clap +// - /usr/lib/clap +// +// Windows +// - %COMMONPROGRAMFILES%\CLAP +// - %LOCALAPPDATA%\Programs\Common\CLAP +// +// MacOS +// - /Library/Audio/Plug-Ins/CLAP +// - ~/Library/Audio/Plug-Ins/CLAP +// +// In addition to the OS-specific default locations above, a CLAP host must query the environment +// for a CLAP_PATH variable, which is a list of directories formatted in the same manner as the host +// OS binary search path (PATH on Unix, separated by `:` and Path on Windows, separated by ';', as +// of this writing). +// +// Each directory should be recursively searched for files and/or bundles as appropriate in your OS +// ending with the extension `.clap`. +// +// init and deinit in most cases are called once, in a matched pair, when the dso is loaded / unloaded. +// In some rare situations it may be called multiple times in a process, so the functions must be defensive, +// mutex locking and counting calls if undertaking non trivial non idempotent actions. +// +// Rationale: +// +// The intent of the init() and deinit() functions is to provide a "normal" initialization patterh +// which occurs when the shared object is loaded or unloaded. As such, hosts will call each once and +// in matched pairs. In CLAP specifications prior to 1.2.0, this single-call was documented as a +// requirement. +// +// We realized, though, that this is not a requirement hosts can meet. If hosts load a plugin +// which itself wraps another CLAP for instance, while also loading that same clap in its memory +// space, both the host and the wrapper will call init() and deinit() and have no means to communicate +// the state. +// +// With CLAP 1.2.0 and beyond we are changing the spec to indicate that a host should make an +// absolute best effort to call init() and deinit() once, and always in matched pairs (for every +// init() which returns true, one deinit() should be called). +// +// This takes the de-facto burden on plugin writers to deal with multiple calls into a hard requirement. +// +// Most init() / deinit() pairs we have seen are the relatively trivial {return true;} and {}. But +// if your init() function does non-trivial one time work, the plugin author must maintain a counter +// and must manage a mutex lock. The most obvious implementation will maintain a static counter and a +// global mutex, increment the counter on each init, decrement it on each deinit, and only undertake +// the init or deinit action when the counter is zero. +typedef struct clap_plugin_entry { + clap_version_t clap_version; // initialized to CLAP_VERSION + + // Initializes the DSO. + // + // This function must be called first, before any-other CLAP-related function or symbol from this + // DSO. + // + // It also must only be called once, until a later call to deinit() is made, after which init() + // can be called once more to re-initialize the DSO. + // This enables hosts to e.g. quickly load and unload a DSO for scanning its plugins, and then + // load it again later to actually use the plugins if needed. + // + // As stated above, even though hosts are forbidden to do so directly, multiple calls before any + // deinit() call may still happen. Implementations *should* take this into account, and *must* + // do so as of CLAP 1.2.0. + // + // It should be as fast as possible, in order to perform a very quick scan of the plugin + // descriptors. + // + // It is forbidden to display graphical user interfaces in this call. + // It is forbidden to perform any user interaction in this call. + // + // If the initialization depends upon expensive computation, maybe try to do them ahead of time + // and cache the result. + // + // Returns true on success. If init() returns false, then the DSO must be considered + // uninitialized, and the host must not call deinit() nor any other CLAP-related symbols from the + // DSO. + // This function also returns true in the case where the DSO is already initialized, and no + // actual initialization work is done in this call, as explain above. + // + // plugin_path is the path to the DSO (Linux, Windows), or the bundle (macOS). + // + // This function may be called on any thread, including a different one from the one a later call + // to deinit() (or a later init()) can be made. + // However, it is forbidden to call this function simultaneously from multiple threads. + // It is also forbidden to call it simultaneously with *any* other CLAP-related symbols from the + // DSO, including (but not limited to) deinit(). + bool(CLAP_ABI *init)(const char *plugin_path); + + // De-initializes the DSO, freeing any resources allocated or initialized by init(). + // + // After this function is called, no more calls into the DSO must be made, except calling init() + // again to re-initialize the DSO. + // This means that after deinit() is called, the DSO can be considered to be in the same state + // as if init() was never called at all yet, enabling it to be re-initialized as needed. + // + // As stated above, even though hosts are forbidden to do so directly, multiple calls before any + // new init() call may still happen. Implementations *should* take this into account, and *must* + // do so as of CLAP 1.2.0. + // + // Just like init(), this function may be called on any thread, including a different one from + // the one init() was called from, or from the one a later init() call can be made. + // However, it is forbidden to call this function simultaneously from multiple threads. + // It is also forbidden to call it simultaneously with *any* other CLAP-related symbols from the + // DSO, including (but not limited to) deinit(). + void(CLAP_ABI *deinit)(void); + + // Get the pointer to a factory. See factory/plugin-factory.h for an example. + // + // Returns null if the factory is not provided. + // The returned pointer must *not* be freed by the caller. + // + // Unlike init() and deinit(), this function can be called simultaneously by multiple threads. + // + // [thread-safe] + const void *(CLAP_ABI *get_factory)(const char *factory_id); +} clap_plugin_entry_t; + +/* Entry point */ +CLAP_EXPORT extern const clap_plugin_entry_t clap_entry; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/events.h b/tests/clap/events.h new file mode 100644 index 0000000..a39df02 --- /dev/null +++ b/tests/clap/events.h @@ -0,0 +1,367 @@ +#pragma once + +#include "private/std.h" +#include "fixedpoint.h" +#include "id.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// event header +// All clap events start with an event header to determine the overall +// size of the event and its type and space (a namespacing for types). +// clap_event objects are contiguous regions of memory which can be copied +// with a memcpy of `size` bytes starting at the top of the header. As +// such, be very careful when designing clap events with internal pointers +// and other non-value-types to consider the lifetime of those members. +typedef struct clap_event_header { + uint32_t size; // event size including this header, eg: sizeof (clap_event_note) + uint32_t time; // sample offset within the buffer for this event + uint16_t space_id; // event space, see clap_host_event_registry + uint16_t type; // event type + uint32_t flags; // see clap_event_flags +} clap_event_header_t; + +// The clap core event space +static const CLAP_CONSTEXPR uint16_t CLAP_CORE_EVENT_SPACE_ID = 0; + +enum clap_event_flags { + // Indicate a live user event, for example a user turning a physical knob + // or playing a physical key. + CLAP_EVENT_IS_LIVE = 1 << 0, + + // Indicate that the event should not be recorded. + // For example this is useful when a parameter changes because of a MIDI CC, + // because if the host records both the MIDI CC automation and the parameter + // automation there will be a conflict. + CLAP_EVENT_DONT_RECORD = 1 << 1, +}; + +// Some of the following events overlap, a note on can be expressed with: +// - CLAP_EVENT_NOTE_ON +// - CLAP_EVENT_MIDI +// - CLAP_EVENT_MIDI2 +// +// The preferred way of sending a note event is to use CLAP_EVENT_NOTE_*. +// +// The same event must not be sent twice: it is forbidden to send a the same note on +// encoded with both CLAP_EVENT_NOTE_ON and CLAP_EVENT_MIDI. +// +// The plugins are encouraged to be able to handle note events encoded as raw midi or midi2, +// or implement clap_plugin_event_filter and reject raw midi and midi2 events. +enum { + // NOTE_ON and NOTE_OFF represent a key pressed and key released event, respectively. + // A NOTE_ON with a velocity of 0 is valid and should not be interpreted as a NOTE_OFF. + // + // NOTE_CHOKE is meant to choke the voice(s), like in a drum machine when a closed hihat + // chokes an open hihat. This event can be sent by the host to the plugin. Here are two use + // cases: + // - a plugin is inside a drum pad in Bitwig Studio's drum machine, and this pad is choked by + // another one + // - the user double-clicks the DAW's stop button in the transport which then stops the sound on + // every track + // + // NOTE_END is sent by the plugin to the host. The port, channel, key and note_id are those given + // by the host in the NOTE_ON event. In other words, this event is matched against the + // plugin's note input port. + // NOTE_END is useful to help the host to match the plugin's voice life time. + // + // When using polyphonic modulations, the host has to allocate and release voices for its + // polyphonic modulator. Yet only the plugin effectively knows when the host should terminate + // a voice. NOTE_END solves that issue in a non-intrusive and cooperative way. + // + // CLAP assumes that the host will allocate a unique voice on NOTE_ON event for a given port, + // channel and key. This voice will run until the plugin will instruct the host to terminate + // it by sending a NOTE_END event. + // + // Consider the following sequence: + // - process() + // Host->Plugin NoteOn(port:0, channel:0, key:16, time:t0) + // Host->Plugin NoteOn(port:0, channel:0, key:64, time:t0) + // Host->Plugin NoteOff(port:0, channel:0, key:16, t1) + // Host->Plugin NoteOff(port:0, channel:0, key:64, t1) + // # on t2, both notes did terminate + // Host->Plugin NoteOn(port:0, channel:0, key:64, t3) + // # Here the plugin finished processing all the frames and will tell the host + // # to terminate the voice on key 16 but not 64, because a note has been started at t3 + // Plugin->Host NoteEnd(port:0, channel:0, key:16, time:ignored) + // + // These four events use clap_event_note. + CLAP_EVENT_NOTE_ON = 0, + CLAP_EVENT_NOTE_OFF = 1, + CLAP_EVENT_NOTE_CHOKE = 2, + CLAP_EVENT_NOTE_END = 3, + + // Represents a note expression. + // Uses clap_event_note_expression. + CLAP_EVENT_NOTE_EXPRESSION = 4, + + // PARAM_VALUE sets the parameter's value; uses clap_event_param_value. + // PARAM_MOD sets the parameter's modulation amount; uses clap_event_param_mod. + // + // The value heard is: param_value + param_mod. + // + // In case of a concurrent global value/modulation versus a polyphonic one, + // the voice should only use the polyphonic one and the polyphonic modulation + // amount will already include the monophonic signal. + CLAP_EVENT_PARAM_VALUE = 5, + CLAP_EVENT_PARAM_MOD = 6, + + // Indicates that the user started or finished adjusting a knob. + // This is not mandatory to wrap parameter changes with gesture events, but this improves + // the user experience a lot when recording automation or overriding automation playback. + // Uses clap_event_param_gesture. + CLAP_EVENT_PARAM_GESTURE_BEGIN = 7, + CLAP_EVENT_PARAM_GESTURE_END = 8, + + CLAP_EVENT_TRANSPORT = 9, // update the transport info; clap_event_transport + CLAP_EVENT_MIDI = 10, // raw midi event; clap_event_midi + CLAP_EVENT_MIDI_SYSEX = 11, // raw midi sysex event; clap_event_midi_sysex + CLAP_EVENT_MIDI2 = 12, // raw midi 2 event; clap_event_midi2 +}; + +// Note on, off, end and choke events. +// +// Clap addresses notes and voices using the 4-value tuple +// (port, channel, key, note_id). Note on/off/end/choke +// events and parameter modulation messages are delivered with +// these values populated. +// +// Values in a note and voice address are either >= 0 if they +// are specified, or -1 to indicate a wildcard. A wildcard +// means a voice with any value in that part of the tuple +// matches the message. +// +// For instance, a (PCKN) of (0, 3, -1, -1) will match all voices +// on channel 3 of port 0. And a PCKN of (-1, 0, 60, -1) will match +// all channel 0 key 60 voices, independent of port or note id. +// +// Especially in the case of note-on note-off pairs, and in the +// absence of voice stacking or polyphonic modulation, a host may +// choose to issue a note id only at note on. So you may see a +// message stream like +// +// CLAP_EVENT_NOTE_ON [0,0,60,184] +// CLAP_EVENT_NOTE_OFF [0,0,60,-1] +// +// and the host will expect the first voice to be released. +// Well constructed plugins will search for voices and notes using +// the entire tuple. +// +// In the case of note on events: +// - The port, channel and key must be specified with a value >= 0 +// - A note-on event with a '-1' for port, channel or key is invalid and +// can be rejected or ignored by a plugin or host. +// - A host which does not support note ids should set the note id to -1. +// +// In the case of note choke or end events: +// - the velocity is ignored. +// - key and channel are used to match active notes +// - note_id is optionally provided by the host +typedef struct clap_event_note { + clap_event_header_t header; + + int32_t note_id; // host provided note id >= 0, or -1 if unspecified or wildcard + int16_t port_index; // port index from ext/note-ports; -1 for wildcard + int16_t channel; // 0..15, same as MIDI1 Channel Number, -1 for wildcard + int16_t key; // 0..127, same as MIDI1 Key Number (60==Middle C), -1 for wildcard + double velocity; // 0..1 +} clap_event_note_t; + +// Note Expressions are well named modifications of a voice targeted to +// voices using the same wildcard rules described above. Note Expressions are delivered +// as sample accurate events and should be applied at the sample when received. +// +// Note expressions are a statement of value, not cumulative. A PAN event of 0 followed by 1 +// followed by 0.5 would pan hard left, hard right, and center. They are intended as +// an offset from the non-note-expression voice default. A voice which had a volume of +// -20db absent note expressions which received a +4db note expression would move the +// voice to -16db. +// +// A plugin which receives a note expression at the same sample as a NOTE_ON event +// should apply that expression to all generated samples. A plugin which receives +// a note expression after a NOTE_ON event should initiate the voice with default +// values and then apply the note expression when received. A plugin may make a choice +// to smooth note expression streams. +enum { + // with 0 < x <= 4, plain = 20 * log(x) + CLAP_NOTE_EXPRESSION_VOLUME = 0, + + // pan, 0 left, 0.5 center, 1 right + CLAP_NOTE_EXPRESSION_PAN = 1, + + // Relative tuning in semitones, from -120 to +120. Semitones are in + // equal temperament and are doubles; the resulting note would be + // retuned by `100 * evt->value` cents. + CLAP_NOTE_EXPRESSION_TUNING = 2, + + // 0..1 + CLAP_NOTE_EXPRESSION_VIBRATO = 3, + CLAP_NOTE_EXPRESSION_EXPRESSION = 4, + CLAP_NOTE_EXPRESSION_BRIGHTNESS = 5, + CLAP_NOTE_EXPRESSION_PRESSURE = 6, +}; +typedef int32_t clap_note_expression; + +typedef struct clap_event_note_expression { + clap_event_header_t header; + + clap_note_expression expression_id; + + // target a specific note_id, port, key and channel, with + // -1 meaning wildcard, per the wildcard discussion above + int32_t note_id; + int16_t port_index; + int16_t channel; + int16_t key; + + double value; // see expression for the range +} clap_event_note_expression_t; + +typedef struct clap_event_param_value { + clap_event_header_t header; + + // target parameter + clap_id param_id; // @ref clap_param_info.id + void *cookie; // @ref clap_param_info.cookie + + // target a specific note_id, port, key and channel, with + // -1 meaning wildcard, per the wildcard discussion above + int32_t note_id; + int16_t port_index; + int16_t channel; + int16_t key; + + double value; +} clap_event_param_value_t; + +typedef struct clap_event_param_mod { + clap_event_header_t header; + + // target parameter + clap_id param_id; // @ref clap_param_info.id + void *cookie; // @ref clap_param_info.cookie + + // target a specific note_id, port, key and channel, with + // -1 meaning wildcard, per the wildcard discussion above + int32_t note_id; + int16_t port_index; + int16_t channel; + int16_t key; + + double amount; // modulation amount +} clap_event_param_mod_t; + +typedef struct clap_event_param_gesture { + clap_event_header_t header; + + // target parameter + clap_id param_id; // @ref clap_param_info.id +} clap_event_param_gesture_t; + +enum clap_transport_flags { + CLAP_TRANSPORT_HAS_TEMPO = 1 << 0, + CLAP_TRANSPORT_HAS_BEATS_TIMELINE = 1 << 1, + CLAP_TRANSPORT_HAS_SECONDS_TIMELINE = 1 << 2, + CLAP_TRANSPORT_HAS_TIME_SIGNATURE = 1 << 3, + CLAP_TRANSPORT_IS_PLAYING = 1 << 4, + CLAP_TRANSPORT_IS_RECORDING = 1 << 5, + CLAP_TRANSPORT_IS_LOOP_ACTIVE = 1 << 6, + CLAP_TRANSPORT_IS_WITHIN_PRE_ROLL = 1 << 7, +}; + +// clap_event_transport provides song position, tempo, and similar information +// from the host to the plugin. There are two ways a host communicates these values. +// In the `clap_process` structure sent to each processing block, the host may +// provide a transport structure which indicates the available information at the +// start of the block. If the host provides sample-accurate tempo or transport changes, +// it can also provide subsequent inter-block transport updates by delivering a new event. +typedef struct clap_event_transport { + clap_event_header_t header; + + uint32_t flags; // see clap_transport_flags + + clap_beattime song_pos_beats; // position in beats + clap_sectime song_pos_seconds; // position in seconds + + double tempo; // in bpm + double tempo_inc; // tempo increment for each sample and until the next + // time info event + + clap_beattime loop_start_beats; + clap_beattime loop_end_beats; + clap_sectime loop_start_seconds; + clap_sectime loop_end_seconds; + + clap_beattime bar_start; // start pos of the current bar + int32_t bar_number; // bar at song pos 0 has the number 0 + + uint16_t tsig_num; // time signature numerator + uint16_t tsig_denom; // time signature denominator +} clap_event_transport_t; + +typedef struct clap_event_midi { + clap_event_header_t header; + + uint16_t port_index; + uint8_t data[3]; +} clap_event_midi_t; + +// clap_event_midi_sysex contains a pointer to a sysex contents buffer. +// The lifetime of this buffer is (from host->plugin) only the process +// call in which the event is delivered or (from plugin->host) only the +// duration of a try_push call. +// +// Since `clap_output_events.try_push` requires hosts to make a copy of +// an event, host implementers receiving sysex messages from plugins need +// to take care to both copy the event (so header, size, etc...) but +// also memcpy the contents of the sysex pointer to host-owned memory, and +// not just copy the data pointer. +// +// Similarly plugins retaining the sysex outside the lifetime of a single +// process call must copy the sysex buffer to plugin-owned memory. +// +// As a consequence, the data structure pointed to by the sysex buffer +// must be contiguous and copyable with `memcpy` of `size` bytes. +typedef struct clap_event_midi_sysex { + clap_event_header_t header; + + uint16_t port_index; + const uint8_t *buffer; // midi buffer. See lifetime comment above. + uint32_t size; +} clap_event_midi_sysex_t; + +// While it is possible to use a series of midi2 event to send a sysex, +// prefer clap_event_midi_sysex if possible for efficiency. +typedef struct clap_event_midi2 { + clap_event_header_t header; + + uint16_t port_index; + uint32_t data[4]; +} clap_event_midi2_t; + +// Input event list. The host will deliver these sorted in sample order. +typedef struct clap_input_events { + void *ctx; // reserved pointer for the list + + // returns the number of events in the list + uint32_t(CLAP_ABI *size)(const struct clap_input_events *list); + + // Don't free the returned event, it belongs to the list + const clap_event_header_t *(CLAP_ABI *get)(const struct clap_input_events *list, uint32_t index); +} clap_input_events_t; + +// Output event list. The plugin must insert events in sample sorted order when inserting events +typedef struct clap_output_events { + void *ctx; // reserved pointer for the list + + // Pushes a copy of the event + // returns false if the event could not be pushed to the queue (out of memory?) + bool(CLAP_ABI *try_push)(const struct clap_output_events *list, + const clap_event_header_t *event); +} clap_output_events_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/ambisonic.h b/tests/clap/ext/ambisonic.h new file mode 100644 index 0000000..8889904 --- /dev/null +++ b/tests/clap/ext/ambisonic.h @@ -0,0 +1,63 @@ +#pragma once + +#include "../plugin.h" + +// This extension can be used to specify the channel mapping used by the plugin. +static CLAP_CONSTEXPR const char CLAP_EXT_AMBISONIC[] = "clap.ambisonic/3"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_AMBISONIC_COMPAT[] = "clap.ambisonic.draft/3"; + +static CLAP_CONSTEXPR const char CLAP_PORT_AMBISONIC[] = "ambisonic"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum clap_ambisonic_ordering { + // FuMa channel ordering + CLAP_AMBISONIC_ORDERING_FUMA = 0, + + // ACN channel ordering + CLAP_AMBISONIC_ORDERING_ACN = 1, +}; + +enum clap_ambisonic_normalization { + CLAP_AMBISONIC_NORMALIZATION_MAXN = 0, + CLAP_AMBISONIC_NORMALIZATION_SN3D = 1, + CLAP_AMBISONIC_NORMALIZATION_N3D = 2, + CLAP_AMBISONIC_NORMALIZATION_SN2D = 3, + CLAP_AMBISONIC_NORMALIZATION_N2D = 4, +}; + +typedef struct clap_ambisonic_config { + uint32_t ordering; // see clap_ambisonic_ordering + uint32_t normalization; // see clap_ambisonic_normalization +} clap_ambisonic_config_t; + +typedef struct clap_plugin_ambisonic { + // Returns true if the given configuration is supported. + // [main-thread] + bool(CLAP_ABI *is_config_supported)(const clap_plugin_t *plugin, + const clap_ambisonic_config_t *config); + + // Returns true on success + // [main-thread] + bool(CLAP_ABI *get_config)(const clap_plugin_t *plugin, + bool is_input, + uint32_t port_index, + clap_ambisonic_config_t *config); + +} clap_plugin_ambisonic_t; + +typedef struct clap_host_ambisonic { + // Informs the host that the info has changed. + // The info can only change when the plugin is de-activated. + // [main-thread] + void(CLAP_ABI *changed)(const clap_host_t *host); +} clap_host_ambisonic_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/audio-ports-activation.h b/tests/clap/ext/audio-ports-activation.h new file mode 100644 index 0000000..f63085c --- /dev/null +++ b/tests/clap/ext/audio-ports-activation.h @@ -0,0 +1,64 @@ +#pragma once + +#include "../plugin.h" + +/// @page Audio Ports Activation +/// +/// This extension provides a way for the host to activate and de-activate audio ports. +/// Deactivating a port provides the following benefits: +/// - the plugin knows ahead of time that a given input is not present and can choose +/// an optimized computation path, +/// - the plugin knows that an output is not consumed by the host, and doesn't need to +/// compute it. +/// +/// Audio ports can only be activated or deactivated when the plugin is deactivated, unless +/// can_activate_while_processing() returns true. +/// +/// Audio buffers must still be provided if the audio port is deactivated. +/// In such case, they shall be filled with 0 (or whatever is the neutral value in your context) +/// and the constant_mask shall be set. +/// +/// Audio ports are initially in the active state after creating the plugin instance. +/// Audio ports state are not saved in the plugin state, so the host must restore the +/// audio ports state after creating the plugin instance. +/// +/// Audio ports state is invalidated by clap_plugin_audio_ports_config.select() and +/// clap_host_audio_ports.rescan(CLAP_AUDIO_PORTS_RESCAN_LIST). + +static CLAP_CONSTEXPR const char CLAP_EXT_AUDIO_PORTS_ACTIVATION[] = + "clap.audio-ports-activation/2"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_AUDIO_PORTS_ACTIVATION_COMPAT[] = + "clap.audio-ports-activation/draft-2"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_audio_ports_activation { + // Returns true if the plugin supports activation/deactivation while processing. + // [main-thread] + bool(CLAP_ABI *can_activate_while_processing)(const clap_plugin_t *plugin); + + // Activate the given port. + // + // It is only possible to activate and de-activate on the audio-thread if + // can_activate_while_processing() returns true. + // + // sample_size indicate if the host will provide 32 bit audio buffers or 64 bits one. + // Possible values are: 32, 64 or 0 if unspecified. + // + // returns false if failed, or invalid parameters + // [active ? audio-thread : main-thread] + bool(CLAP_ABI *set_active)(const clap_plugin_t *plugin, + bool is_input, + uint32_t port_index, + bool is_active, + uint32_t sample_size); +} clap_plugin_audio_ports_activation_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/audio-ports-config.h b/tests/clap/ext/audio-ports-config.h new file mode 100644 index 0000000..2ab8657 --- /dev/null +++ b/tests/clap/ext/audio-ports-config.h @@ -0,0 +1,109 @@ +#pragma once + +#include "../string-sizes.h" +#include "../plugin.h" +#include "audio-ports.h" + +/// @page Audio Ports Config +/// +/// This extension let the plugin provide port configurations presets. +/// For example mono, stereo, surround, ambisonic, ... +/// +/// After the plugin initialization, the host may scan the list of configurations and eventually +/// select one that fits the plugin context. The host can only select a configuration if the plugin +/// is deactivated. +/// +/// A configuration is a very simple description of the audio ports: +/// - it describes the main input and output ports +/// - it has a name that can be displayed to the user +/// +/// The idea behind the configurations, is to let the user choose one via a menu. +/// +/// Plugins with very complex configuration possibilities should let the user configure the ports +/// from the plugin GUI, and call @ref clap_host_audio_ports.rescan(CLAP_AUDIO_PORTS_RESCAN_ALL). +/// +/// To inquire the exact bus layout, the plugin implements the clap_plugin_audio_ports_config_info_t +/// extension where all busses can be retrieved in the same way as in the audio-port extension. + +static CLAP_CONSTEXPR const char CLAP_EXT_AUDIO_PORTS_CONFIG[] = "clap.audio-ports-config"; + +static CLAP_CONSTEXPR const char CLAP_EXT_AUDIO_PORTS_CONFIG_INFO[] = + "clap.audio-ports-config-info/1"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_AUDIO_PORTS_CONFIG_INFO_COMPAT[] = + "clap.audio-ports-config-info/draft-0"; + +#ifdef __cplusplus +extern "C" { +#endif + +// Minimalistic description of ports configuration +typedef struct clap_audio_ports_config { + clap_id id; + char name[CLAP_NAME_SIZE]; + + uint32_t input_port_count; + uint32_t output_port_count; + + // main input info + bool has_main_input; + uint32_t main_input_channel_count; + const char *main_input_port_type; + + // main output info + bool has_main_output; + uint32_t main_output_channel_count; + const char *main_output_port_type; +} clap_audio_ports_config_t; + +// The audio ports config scan has to be done while the plugin is deactivated. +typedef struct clap_plugin_audio_ports_config { + // Gets the number of available configurations + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin); + + // Gets information about a configuration + // Returns true on success and stores the result into config. + // [main-thread] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, + uint32_t index, + clap_audio_ports_config_t *config); + + // Selects the configuration designated by id + // Returns true if the configuration could be applied. + // Once applied the host should scan again the audio ports. + // [main-thread & plugin-deactivated] + bool(CLAP_ABI *select)(const clap_plugin_t *plugin, clap_id config_id); +} clap_plugin_audio_ports_config_t; + +// Extended config info +typedef struct clap_plugin_audio_ports_config_info { + + // Gets the id of the currently selected config, or CLAP_INVALID_ID if the current port + // layout isn't part of the config list. + // + // [main-thread] + clap_id(CLAP_ABI *current_config)(const clap_plugin_t *plugin); + + // Get info about an audio port, for a given config_id. + // This is analogous to clap_plugin_audio_ports.get(). + // Returns true on success and stores the result into info. + // [main-thread] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, + clap_id config_id, + uint32_t port_index, + bool is_input, + clap_audio_port_info_t *info); +} clap_plugin_audio_ports_config_info_t; + +typedef struct clap_host_audio_ports_config { + // Rescan the full list of configs. + // [main-thread] + void(CLAP_ABI *rescan)(const clap_host_t *host); +} clap_host_audio_ports_config_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/audio-ports.h b/tests/clap/ext/audio-ports.h new file mode 100644 index 0000000..3988049 --- /dev/null +++ b/tests/clap/ext/audio-ports.h @@ -0,0 +1,116 @@ +#pragma once + +#include "../plugin.h" +#include "../string-sizes.h" + +/// @page Audio Ports +/// +/// This extension provides a way for the plugin to describe its current audio ports. +/// +/// If the plugin does not implement this extension, it won't have audio ports. +/// +/// 32 bits support is required for both host and plugins. 64 bits audio is optional. +/// +/// The plugin is only allowed to change its ports configuration while it is deactivated. + +static CLAP_CONSTEXPR const char CLAP_EXT_AUDIO_PORTS[] = "clap.audio-ports"; +static CLAP_CONSTEXPR const char CLAP_PORT_MONO[] = "mono"; +static CLAP_CONSTEXPR const char CLAP_PORT_STEREO[] = "stereo"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // This port is the main audio input or output. + // There can be only one main input and main output. + // Main port must be at index 0. + CLAP_AUDIO_PORT_IS_MAIN = 1 << 0, + + // This port can be used with 64 bits audio + CLAP_AUDIO_PORT_SUPPORTS_64BITS = 1 << 1, + + // 64 bits audio is preferred with this port + CLAP_AUDIO_PORT_PREFERS_64BITS = 1 << 2, + + // This port must be used with the same sample size as all the other ports which have this flag. + // In other words if all ports have this flag then the plugin may either be used entirely with + // 64 bits audio or 32 bits audio, but it can't be mixed. + CLAP_AUDIO_PORT_REQUIRES_COMMON_SAMPLE_SIZE = 1 << 3, +}; + +typedef struct clap_audio_port_info { + // id identifies a port and must be stable. + // id may overlap between input and output ports. + clap_id id; + char name[CLAP_NAME_SIZE]; // displayable name + + uint32_t flags; + uint32_t channel_count; + + // If null or empty then it is unspecified (arbitrary audio). + // This field can be compared against: + // - CLAP_PORT_MONO + // - CLAP_PORT_STEREO + // - CLAP_PORT_SURROUND (defined in the surround extension) + // - CLAP_PORT_AMBISONIC (defined in the ambisonic extension) + // + // An extension can provide its own port type and way to inspect the channels. + const char *port_type; + + // in-place processing: allow the host to use the same buffer for input and output + // if supported set the pair port id. + // if not supported set to CLAP_INVALID_ID + clap_id in_place_pair; +} clap_audio_port_info_t; + +// The audio ports scan has to be done while the plugin is deactivated. +typedef struct clap_plugin_audio_ports { + // Number of ports, for either input or output + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin, bool is_input); + + // Get info about an audio port. + // Returns true on success and stores the result into info. + // [main-thread] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, + uint32_t index, + bool is_input, + clap_audio_port_info_t *info); +} clap_plugin_audio_ports_t; + +enum { + // The ports name did change, the host can scan them right away. + CLAP_AUDIO_PORTS_RESCAN_NAMES = 1 << 0, + + // [!active] The flags did change + CLAP_AUDIO_PORTS_RESCAN_FLAGS = 1 << 1, + + // [!active] The channel_count did change + CLAP_AUDIO_PORTS_RESCAN_CHANNEL_COUNT = 1 << 2, + + // [!active] The port type did change + CLAP_AUDIO_PORTS_RESCAN_PORT_TYPE = 1 << 3, + + // [!active] The in-place pair did change, this requires. + CLAP_AUDIO_PORTS_RESCAN_IN_PLACE_PAIR = 1 << 4, + + // [!active] The list of ports have changed: entries have been removed/added. + CLAP_AUDIO_PORTS_RESCAN_LIST = 1 << 5, +}; + +typedef struct clap_host_audio_ports { + // Checks if the host allows a plugin to change a given aspect of the audio ports definition. + // [main-thread] + bool(CLAP_ABI *is_rescan_flag_supported)(const clap_host_t *host, uint32_t flag); + + // Rescan the full list of audio ports according to the flags. + // It is illegal to ask the host to rescan with a flag that is not supported. + // Certain flags require the plugin to be de-activated. + // [main-thread] + void(CLAP_ABI *rescan)(const clap_host_t *host, uint32_t flags); +} clap_host_audio_ports_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/configurable-audio-ports.h b/tests/clap/ext/configurable-audio-ports.h new file mode 100644 index 0000000..86688e7 --- /dev/null +++ b/tests/clap/ext/configurable-audio-ports.h @@ -0,0 +1,63 @@ +#pragma once + +#include "audio-ports.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// This extension lets the host configure the plugin's input and output audio ports. +// This is a "push" approach to audio ports configuration. + +static CLAP_CONSTEXPR const char CLAP_EXT_CONFIGURABLE_AUDIO_PORTS[] = + "clap.configurable-audio-ports/1"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_CONFIGURABLE_AUDIO_PORTS_COMPAT[] = + "clap.configurable-audio-ports.draft1"; + +typedef struct clap_audio_port_configuration_request { + // Identifies the port by is_input and port_index + bool is_input; + uint32_t port_index; + + // The requested number of channels. + uint32_t channel_count; + + // The port type, see audio-ports.h, clap_audio_port_info.port_type for interpretation. + const char *port_type; + + // cast port_details according to port_type: + // - CLAP_PORT_MONO: (discard) + // - CLAP_PORT_STEREO: (discard) + // - CLAP_PORT_SURROUND: const uint8_t *channel_map + // - CLAP_PORT_AMBISONIC: const clap_ambisonic_config_t *info + const void *port_details; +} clap_audio_port_configuration_request_t; + +typedef struct clap_plugin_configurable_audio_ports { + // Returns true if the given configurations can be applied using apply_configuration(). + // [main-thread && !active] + bool(CLAP_ABI *can_apply_configuration)( + const clap_plugin_t *plugin, + const struct clap_audio_port_configuration_request *requests, + uint32_t request_count); + + // Submit a bunch of configuration requests which will atomically be applied together, + // or discarded together. + // + // Once the configuration is successfully applied, it isn't necessary for the plugin to call + // clap_host_audio_ports->changed(); and it isn't necessary for the host to scan the + // audio ports. + // + // Returns true if applied. + // [main-thread && !active] + bool(CLAP_ABI *apply_configuration)(const clap_plugin_t *plugin, + const struct clap_audio_port_configuration_request *requests, + uint32_t request_count); +} clap_plugin_configurable_audio_ports_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/context-menu.h b/tests/clap/ext/context-menu.h new file mode 100644 index 0000000..293f59a --- /dev/null +++ b/tests/clap/ext/context-menu.h @@ -0,0 +1,167 @@ +#pragma once + +#include "../plugin.h" + +// This extension lets the host and plugin exchange menu items and let the plugin ask the host to +// show its context menu. + +static CLAP_CONSTEXPR const char CLAP_EXT_CONTEXT_MENU[] = "clap.context-menu/1"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_CONTEXT_MENU_COMPAT[] = "clap.context-menu.draft/0"; + +#ifdef __cplusplus +extern "C" { +#endif + +// There can be different target kind for a context menu +enum { + CLAP_CONTEXT_MENU_TARGET_KIND_GLOBAL = 0, + CLAP_CONTEXT_MENU_TARGET_KIND_PARAM = 1, +}; + +// Describes the context menu target +typedef struct clap_context_menu_target { + uint32_t kind; + clap_id id; +} clap_context_menu_target_t; + +enum { + // Adds a clickable menu entry. + // data: const clap_context_menu_item_entry_t* + CLAP_CONTEXT_MENU_ITEM_ENTRY, + + // Adds a clickable menu entry which will feature both a checkmark and a label. + // data: const clap_context_menu_item_check_entry_t* + CLAP_CONTEXT_MENU_ITEM_CHECK_ENTRY, + + // Adds a separator line. + // data: NULL + CLAP_CONTEXT_MENU_ITEM_SEPARATOR, + + // Starts a sub menu with the given label. + // data: const clap_context_menu_item_begin_submenu_t* + CLAP_CONTEXT_MENU_ITEM_BEGIN_SUBMENU, + + // Ends the current sub menu. + // data: NULL + CLAP_CONTEXT_MENU_ITEM_END_SUBMENU, + + // Adds a title entry + // data: const clap_context_menu_item_title_t * + CLAP_CONTEXT_MENU_ITEM_TITLE, +}; +typedef uint32_t clap_context_menu_item_kind_t; + +typedef struct clap_context_menu_entry { + // text to be displayed + const char *label; + + // if false, then the menu entry is greyed out and not clickable + bool is_enabled; + clap_id action_id; +} clap_context_menu_entry_t; + +typedef struct clap_context_menu_check_entry { + // text to be displayed + const char *label; + + // if false, then the menu entry is greyed out and not clickable + bool is_enabled; + + // if true, then the menu entry will be displayed as checked + bool is_checked; + clap_id action_id; +} clap_context_menu_check_entry_t; + +typedef struct clap_context_menu_item_title { + // text to be displayed + const char *title; + + // if false, then the menu entry is greyed out + bool is_enabled; +} clap_context_menu_item_title_t; + +typedef struct clap_context_menu_submenu { + // text to be displayed + const char *label; + + // if false, then the menu entry is greyed out and won't show submenu + bool is_enabled; +} clap_context_menu_submenu_t; + +// Context menu builder. +// This object isn't thread-safe and must be used on the same thread as it was provided. +typedef struct clap_context_menu_builder { + void *ctx; + + // Adds an entry to the menu. + // item_data type is determined by item_kind. + // Returns true on success. + bool(CLAP_ABI *add_item)(const struct clap_context_menu_builder *builder, + clap_context_menu_item_kind_t item_kind, + const void *item_data); + + // Returns true if the menu builder supports the given item kind + bool(CLAP_ABI *supports)(const struct clap_context_menu_builder *builder, + clap_context_menu_item_kind_t item_kind); +} clap_context_menu_builder_t; + +typedef struct clap_plugin_context_menu { + // Insert plugin's menu items into the menu builder. + // If target is null, assume global context. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *populate)(const clap_plugin_t *plugin, + const clap_context_menu_target_t *target, + const clap_context_menu_builder_t *builder); + + // Performs the given action, which was previously provided to the host via populate(). + // If target is null, assume global context. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *perform)(const clap_plugin_t *plugin, + const clap_context_menu_target_t *target, + clap_id action_id); +} clap_plugin_context_menu_t; + +typedef struct clap_host_context_menu { + // Insert host's menu items into the menu builder. + // If target is null, assume global context. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *populate)(const clap_host_t *host, + const clap_context_menu_target_t *target, + const clap_context_menu_builder_t *builder); + + // Performs the given action, which was previously provided to the plugin via populate(). + // If target is null, assume global context. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *perform)(const clap_host_t *host, + const clap_context_menu_target_t *target, + clap_id action_id); + + // Returns true if the host can display a popup menu for the plugin. + // This may depend upon the current windowing system used to display the plugin, so the + // return value is invalidated after creating the plugin window. + // [main-thread] + bool(CLAP_ABI *can_popup)(const clap_host_t *host); + + // Shows the host popup menu for a given parameter. + // If the plugin is using embedded GUI, then x and y are relative to the plugin's window, + // otherwise they're absolute coordinate, and screen index might be set accordingly. + // If target is null, assume global context. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *popup)(const clap_host_t *host, + const clap_context_menu_target_t *target, + int32_t screen_index, + int32_t x, + int32_t y); +} clap_host_context_menu_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/extensible-audio-ports.h b/tests/clap/ext/draft/extensible-audio-ports.h new file mode 100644 index 0000000..8f97b0c --- /dev/null +++ b/tests/clap/ext/draft/extensible-audio-ports.h @@ -0,0 +1,33 @@ +#pragma once + +#include "../audio-ports.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// This extension lets the host add and remove audio ports to the plugin. +static CLAP_CONSTEXPR const char CLAP_EXT_EXTENSIBLE_AUDIO_PORTS[] = + "clap.extensible-audio-ports/1"; + +typedef struct clap_plugin_extensible_audio_ports { + // Asks the plugin to add a new port (at the end of the list), with the following settings. + // port_type: see clap_audio_port_info.port_type for interpretation. + // port_details: see clap_audio_port_configuration_request.port_details for interpretation. + // Returns true on success. + // [main-thread && !is_active] + bool(CLAP_ABI *add_port)(const clap_plugin_t *plugin, + bool is_input, + uint32_t channel_count, + const char *port_type, + const void *port_details); + + // Asks the plugin to remove a port. + // Returns true on success. + // [main-thread && !is_active] + bool(CLAP_ABI *remove_port)(const clap_plugin_t *plugin, bool is_input, uint32_t index); +} clap_plugin_extensible_audio_ports_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/gain-adjustment-metering.h b/tests/clap/ext/draft/gain-adjustment-metering.h new file mode 100644 index 0000000..3bf2935 --- /dev/null +++ b/tests/clap/ext/draft/gain-adjustment-metering.h @@ -0,0 +1,34 @@ +#pragma once + +#include "../../plugin.h" + +// This extension lets the plugin report the current gain adjustment +// (typically, gain reduction) to the host. + +static CLAP_CONSTEXPR const char CLAP_EXT_GAIN_ADJUSTMENT_METERING[] = "clap.gain-adjustment-metering/0"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_gain_adjustment_metering { + // Returns the current gain adjustment in dB. The value is intended + // for informational display, for example in a host meter or tooltip. + // The returned value represents the gain adjustment that the plugin + // applied to the last sample in the most recently processed block. + // + // The returned value is in dB. Zero means the plugin is applying no gain + // reduction, or is not processing. A negative value means the plugin is + // applying gain reduction, as with a compressor or limiter. A positive + // value means the plugin is adding gain, as with an expander. The value + // represents the dynamic gain reduction or expansion applied by the + // plugin, before any make-up gain or other adjustment. A single value is + // returned for all audio channels. + // + // [audio-thread] + double(CLAP_ABI *get)(const clap_plugin_t *plugin); +} clap_plugin_gain_adjustment_metering_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/mini-curve-display.h b/tests/clap/ext/draft/mini-curve-display.h new file mode 100644 index 0000000..ad518eb --- /dev/null +++ b/tests/clap/ext/draft/mini-curve-display.h @@ -0,0 +1,153 @@ +#pragma once + +#include "../../plugin.h" + +// This extension allows a host to render a small curve provided by the plugin. +// A useful application is to render an EQ frequency response in the DAW mixer view. + +static CLAP_CONSTEXPR const char CLAP_EXT_MINI_CURVE_DISPLAY[] = "clap.mini-curve-display/3"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum clap_mini_curve_display_curve_kind { + // If the curve's kind doesn't fit in any proposed kind, use this one + // and perhaps, make a pull request to extend the list. + CLAP_MINI_CURVE_DISPLAY_CURVE_KIND_UNSPECIFIED = 0, + + // The mini curve is intended to draw the total gain response of the plugin. + // In this case the y values are in dB and the x values are in Hz (logarithmic). + // This would be useful in for example an equalizer. + CLAP_MINI_CURVE_DISPLAY_CURVE_KIND_GAIN_RESPONSE = 1, + + // The mini curve is intended to draw the total phase response of the plugin. + // In this case the y values are in radians and the x values are in Hz (logarithmic). + // This would be useful in for example an equalizer. + CLAP_MINI_CURVE_DISPLAY_CURVE_KIND_PHASE_RESPONSE = 2, + + // The mini curve is intended to draw the transfer curve of the plugin. + // In this case the both x and y values are in dB. + // This would be useful in for example a compressor or distortion plugin. + CLAP_MINI_CURVE_DISPLAY_CURVE_KIND_TRANSFER_CURVE = 3, + + // This mini curve is intended to draw gain reduction over time. In this case + // x refers to the window in seconds and y refers to level in dB, x_min is + // always 0, and x_max would be the duration of the window. + // This would be useful in for example a compressor or limiter. + CLAP_MINI_CURVE_DISPLAY_CURVE_KIND_GAIN_REDUCTION = 4, + + // This curve is intended as a generic time series plot. In this case + // x refers to the window in seconds. x_min is always 0, and x_max would be the duration of the + // window. + // Y is not specified and up to the plugin. + CLAP_MINI_CURVE_DISPLAY_CURVE_KIND_TIME_SERIES = 5, + + // Note: more entries could be added here in the future +}; + +typedef struct clap_mini_curve_display_curve_hints { + + // Range for the x axis. + double x_min; + double x_max; + + // Range for the y axis. + double y_min; + double y_max; + +} clap_mini_curve_display_curve_hints_t; + +// A set of points representing the curve to be painted. +typedef struct clap_mini_curve_display_curve_data { + // Indicates the kind of curve those values represent, the host can use this + // information to paint the curve using a meaningful color. + int32_t curve_kind; + + // values[0] will be the leftmost value and values[data_size -1] will be the rightmost + // value. + // + // The value 0 and UINT16_MAX won't be painted. + // The value 1 will be at the bottom of the curve and UINT16_MAX - 1 will be at the top. + uint16_t *values; + uint32_t values_count; +} clap_mini_curve_display_curve_data_t; + +typedef struct clap_plugin_mini_curve_display { + // Returns the number of curves the plugin wants to paint. + // Be aware that the space to display those curves will be small, and too much data will make + // the output hard to read. + uint32_t(CLAP_ABI *get_curve_count)(const clap_plugin_t *plugin); + + // Renders the curve into each the curves buffer. + // + // curves is an array, and each entries (up to curves_size) contains pre-allocated + // values buffer that must be filled by the plugin. + // + // The host will "stack" the curves, from the first one to the last one. + // curves[0] is the first curve to be painted. + // curves[n + 1] will be painted over curves[n]. + // + // Returns the number of curves rendered. + // [main-thread] + uint32_t(CLAP_ABI *render)(const clap_plugin_t *plugin, + clap_mini_curve_display_curve_data_t *curves, + uint32_t curves_size); + + // Tells the plugin if the curve is currently observed or not. + // When it isn't observed render() can't be called. + // + // When is_obseverd becomes true, the curve content and axis name are implicitly invalidated. So + // the plugin don't need to call host->changed. + // + // [main-thread] + void(CLAP_ABI *set_observed)(const clap_plugin_t *plugin, bool is_observed); + + // Retrives the axis name. + // x_name and y_name must not to be null. + // Returns true on success, if the name capacity was sufficient. + // [main-thread] + bool(CLAP_ABI *get_axis_name)(const clap_plugin_t *plugin, + uint32_t curve_index, + char *x_name, + char *y_name, + uint32_t name_capacity); +} clap_plugin_mini_curve_display_t; + +enum clap_mini_curve_display_change_flags { + // Informs the host that the curve content changed. + // Can only be called if the curve is observed and is static. + CLAP_MINI_CURVE_DISPLAY_CURVE_CHANGED = 1 << 0, + + // Informs the host that the curve axis name changed. + // Can only be called if the curve is observed. + CLAP_MINI_CURVE_DISPLAY_AXIS_NAME_CHANGED = 1 << 1, +}; + +typedef struct clap_host_mini_curve_display { + // Fills in the given clap_mini_display_curve_hints_t structure and returns + // true if successful. If not, return false. + // [main-thread] + bool(CLAP_ABI *get_hints)(const clap_host_t *host, + uint32_t kind, + clap_mini_curve_display_curve_hints_t *hints); + + // Mark the curve as being static or dynamic. + // The curve is initially considered as static, though the plugin should explicitely + // initialize this state. + // + // When static, the curve changes will be notified by calling host->changed(). + // When dynamic, the curve is constantly changing and the host is expected to + // periodically re-render. + // + // [main-thread] + void(CLAP_ABI *set_dynamic)(const clap_host_t *host, bool is_dynamic); + + // See clap_mini_curve_display_change_flags + // [main-thread] + void(CLAP_ABI *changed)(const clap_host_t *host, uint32_t flags); +} clap_host_mini_curve_display_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/project-location.h b/tests/clap/ext/draft/project-location.h new file mode 100644 index 0000000..4496cc3 --- /dev/null +++ b/tests/clap/ext/draft/project-location.h @@ -0,0 +1,108 @@ +#pragma once + +#include "../../color.h" +#include "../../plugin.h" +#include "../../string-sizes.h" + +// This extension allows a host to tell the plugin more about its position +// within a project or session. + +static CLAP_CONSTEXPR const char CLAP_EXT_PROJECT_LOCATION[] = "clap.project-location/2"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum clap_project_location_kind { + // Represents a document/project/session. + CLAP_PROJECT_LOCATION_PROJECT = 1, + + // Represents a group of tracks. + // It can contain track groups, tracks, and devices (post processing). + // The first device within a track group has the index of + // the last track or track group within this group + 1. + CLAP_PROJECT_LOCATION_TRACK_GROUP = 2, + + // Represents a single track. + // It contains devices (serial). + CLAP_PROJECT_LOCATION_TRACK = 3, + + // Represents a single device. + // It can contain other nested device chains. + CLAP_PROJECT_LOCATION_DEVICE = 4, + + // Represents a nested device chain (serial). + // Its parent must be a device. + // It contains other devices. + CLAP_PROJECT_LOCATION_NESTED_DEVICE_CHAIN = 5, +}; + +enum clap_project_location_track_kind { + // This track is an instrument track. + CLAP_PROJECT_LOCATION_INSTUMENT_TRACK = 1, + + // This track is an audio track. + CLAP_PROJECT_LOCATION_AUDIO_TRACK = 2, + + // This track is both an instrument and audio track. + CLAP_PROJECT_LOCATION_HYBRID_TRACK = 3, + + // This track is a return track. + CLAP_PROJECT_LOCATION_RETURN_TRACK = 4, + + // This track is a master track. + // Each group have a master track for processing the sum of all its children tracks. + CLAP_PROJECT_LOCATION_MASTER_TRACK = 5, +}; + +enum clap_project_location_flags { + CLAP_PROJECT_LOCATION_HAS_INDEX = 1 << 0, + CLAP_PROJECT_LOCATION_HAS_COLOR = 1 << 1, +}; + +typedef struct clap_project_location_element { + // A bit-mask, see clap_project_location_flags. + uint64_t flags; + + // Kind of the element, must be one of the CLAP_PROJECT_LOCATION_* values. + uint32_t kind; + + // Only relevant if kind is CLAP_PLUGIN_LOCATION_TRACK. + // see enum CLAP_PROJECT_LOCATION_track_kind. + uint32_t track_kind; + + // Index within the parent element. + // Only usable if CLAP_PROJECT_LOCATION_HAS_INDEX is set in flags. + uint32_t index; + + // Internal ID of the element. + // This is not intended for display to the user, + // but rather to give the host a potential quick way for lookups. + char id[CLAP_PATH_SIZE]; + + // User friendly name of the element. + char name[CLAP_NAME_SIZE]; + + // Color for this element. + // Only usable if CLAP_PROJECT_LOCATION_HAS_COLOR is set in flags. + clap_color_t color; +} clap_project_location_element_t; + +typedef struct clap_plugin_project_location { + // Called by the host when the location of the plugin instance changes. + // + // The last item in this array always refers to the device itself, and as + // such is expected to be of kind CLAP_PLUGIN_LOCATION_DEVICE. + // The first item in this array always refers to the project this device is in and must be of + // kind CLAP_PROJECT_LOCATION_PROJECT. The path is expected to be something like: PROJECT > + // TRACK_GROUP+ > TRACK > (DEVICE > NESTED_DEVICE_CHAIN)* > DEVICE + // + // [main-thread] + void(CLAP_ABI *set)(const clap_plugin_t *plugin, + const clap_project_location_element_t *path, + uint32_t num_elements); +} clap_plugin_project_location_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/resource-directory.h b/tests/clap/ext/draft/resource-directory.h new file mode 100644 index 0000000..6b8bd57 --- /dev/null +++ b/tests/clap/ext/draft/resource-directory.h @@ -0,0 +1,88 @@ +#pragma once + +#include "../../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_RESOURCE_DIRECTORY[] = "clap.resource-directory/1"; + +#ifdef __cplusplus +extern "C" { +#endif + +/// @page Resource Directory +/// +/// This extension provides a way for the plugin to store its resources as file in a directory +/// provided by the host and recover them later on. +/// +/// The plugin **must** store relative path in its state toward resource directories. +/// +/// Resource sharing: +/// - shared directory is shared among all plugin instances, hence mostly appropriate for read-only +/// content +/// -> suitable for read-only content +/// - exclusive directory is exclusive to the plugin instance +/// -> if the plugin, then its exclusive directory must be duplicated too +/// -> suitable for read-write content +/// +/// Keeping the shared directory clean: +/// - to avoid clashes in the shared directory, plugins are encouraged to organize their files in +/// sub-folders, for example create one subdirectory using the vendor name +/// - don't use symbolic links or hard links which points outside of the directory +/// +/// Resource life-time: +/// - exclusive folder content is managed by the plugin instance +/// - exclusive folder content is deleted when the plugin instance is removed from the project +/// - shared folder content isn't managed by the host, until all plugins using the shared directory +/// are removed from the project +/// +/// Note for the host +/// - try to use the filesystem's copy-on-write feature when possible for reducing exclusive folder +/// space usage on duplication +/// - host can "garbage collect" the files in the shared folder using: +/// clap_plugin_resource_directory.get_files_count() +/// clap_plugin_resource_directory.get_file_path() +/// but be **very** careful before deleting any resources + +typedef struct clap_plugin_resource_directory { + // Sets the directory in which the plugin can save its resources. + // The directory remains valid until it is overridden or the plugin is destroyed. + // If path is null or blank, it clears the directory location. + // path must be absolute. + // [main-thread] + void(CLAP_ABI *set_directory)(const clap_plugin_t *plugin, const char *path, bool is_shared); + + // Asks the plugin to put its resources into the resource directory. + // It is not necessary to collect files which belongs to the plugin's + // factory content unless the param all is true. + // [main-thread] + void(CLAP_ABI *collect)(const clap_plugin_t *plugin, bool all); + + // Returns the number of files used by the plugin in the shared resource folder. + // [main-thread] + uint32_t(CLAP_ABI *get_files_count)(const clap_plugin_t *plugin); + + // Retrieves relative file path to the resource directory. + // @param path writable memory to store the path + // @param path_size number of available bytes in path + // Returns the number of bytes in the path, or -1 on error + // [main-thread] + int32_t(CLAP_ABI *get_file_path)(const clap_plugin_t *plugin, + uint32_t index, + char *path, + uint32_t path_size); +} clap_plugin_resource_directory_t; + +typedef struct clap_host_resource_directory { + // Request the host to setup a resource directory with the specified sharing. + // Returns true if the host will perform the request. + // [main-thread] + bool(CLAP_ABI *request_directory)(const clap_host_t *host, bool is_shared); + + // Tell the host that the resource directory of the specified sharing is no longer required. + // If is_shared = false, then the host may delete the directory content. + // [main-thread] + void(CLAP_ABI *release_directory)(const clap_host_t *host, bool is_shared); +} clap_host_resource_directory_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/scratch-memory.h b/tests/clap/ext/draft/scratch-memory.h new file mode 100644 index 0000000..8beaa84 --- /dev/null +++ b/tests/clap/ext/draft/scratch-memory.h @@ -0,0 +1,90 @@ +#pragma once + +#include "../../plugin.h" + +// This extension lets the plugin request "scratch" memory from the host. +// +// The scratch memory is thread-local, and can be accessed during +// `clap_plugin->process()` and `clap_plugin_thread_pool->exec()`; +// its content is not persistent between callbacks. +// +// The motivation for this extension is to allow the plugin host +// to "share" a single scratch buffer across multiple plugin +// instances. +// +// For example, imagine the host needs to process N plugins +// in sequence, and each plugin requires 10K of scratch memory. +// If each plugin pre-allocates its own scratch memory, then N * 10K +// of memory is being allocated in total. However, if each plugin +// requests 10K of scratch memory from the host, then the host can +// allocate a single 10K scratch buffer, and make it available to all +// plugins. +// +// This optimization may allow for reduced memory usage and improved +// CPU cache usage. + +static CLAP_CONSTEXPR const char CLAP_EXT_SCRATCH_MEMORY[] = "clap.scratch-memory/1"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_host_scratch_memory { + // Asks the host to reserve scratch memory. + // + // The plugin may call this method multiple times (for + // example, gradually decreasing the amount of scratch + // being asked for until the host returns true), however, + // the plugin should avoid calling this method un-neccesarily + // since the host implementation may be relatively expensive. + // If the plugin calls `reserve()` multiple times, then the + // last call invalidates all previous calls. + // + // De-activating the plugin releases the scratch memory. + // + // `max_concurrency_hint` is an optional hint which indicates + // the maximum number of threads concurrently accessing the scratch memory. + // Set to 0 if unspecified. + // + // Returns true on success. + // + // [main-thread & being-activated] + bool(CLAP_ABI *reserve)(const clap_host_t *host, + uint32_t scratch_size_bytes, + uint32_t max_concurrency_hint); + + // Returns a pointer to the "thread-local" scratch memory. + // + // If the scratch memory wasn't successfully reserved, returns NULL. + // + // If the plugin crosses `max_concurrency_hint`, then the return value + // is either NULL or a valid scratch memory pointer. + // + // This method may only be called by the plugin from the audio thread, + // (i.e. during the process() or thread_pool.exec() callback), and + // the provided memory is only valid until the plugin returns from + // that callback. The plugin must not hold any references to data + // that lives in the scratch memory after returning from the callback, + // as that data will likely be over-written by another plugin using + // the same scratch memory. + // + // The provided memory is not initialized, and may have been used + // by other plugin instances, so the plugin must correctly initialize + // the memory when using it. + // + // The provided memory is owned by the host, so the plugin must not + // free the memory. + // + // If the plugin wants to share the same scratch memory pointer with + // many threads, it must access the the scratch at the beginning of the + // `process()` callback, cache the returned pointer before calling + // `clap_host_thread_pool->request_exec()` and clear the cached pointer + // before returning from `process()`. + // + // [audio-thread] + void *(CLAP_ABI *access)(const clap_host_t *host); +} clap_host_scratch_memory_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/transport-control.h b/tests/clap/ext/draft/transport-control.h new file mode 100644 index 0000000..8085cee --- /dev/null +++ b/tests/clap/ext/draft/transport-control.h @@ -0,0 +1,66 @@ +#pragma once + +#include "../../plugin.h" + +// This extension lets the plugin submit transport requests to the host. +// The host has no obligation to execute these requests, so the interface may be +// partially working. + +static CLAP_CONSTEXPR const char CLAP_EXT_TRANSPORT_CONTROL[] = "clap.transport-control/1"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_host_transport_control { + // Jumps back to the start point and starts the transport + // [main-thread] + void(CLAP_ABI *request_start)(const clap_host_t *host); + + // Stops the transport, and jumps to the start point + // [main-thread] + void(CLAP_ABI *request_stop)(const clap_host_t *host); + + // If not playing, starts the transport from its current position + // [main-thread] + void(CLAP_ABI *request_continue)(const clap_host_t *host); + + // If playing, stops the transport at the current position + // [main-thread] + void(CLAP_ABI *request_pause)(const clap_host_t *host); + + // Equivalent to what "space bar" does with most DAWs + // [main-thread] + void(CLAP_ABI *request_toggle_play)(const clap_host_t *host); + + // Jumps the transport to the given position. + // Does not start the transport. + // [main-thread] + void(CLAP_ABI *request_jump)(const clap_host_t *host, clap_beattime position); + + // Sets the loop region + // [main-thread] + void(CLAP_ABI *request_loop_region)(const clap_host_t *host, + clap_beattime start, + clap_beattime duration); + + // Toggles looping + // [main-thread] + void(CLAP_ABI *request_toggle_loop)(const clap_host_t *host); + + // Enables/Disables looping + // [main-thread] + void(CLAP_ABI *request_enable_loop)(const clap_host_t *host, bool is_enabled); + + // Enables/Disables recording + // [main-thread] + void(CLAP_ABI *request_record)(const clap_host_t *host, bool is_recording); + + // Toggles recording + // [main-thread] + void(CLAP_ABI *request_toggle_record)(const clap_host_t *host); +} clap_host_transport_control_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/triggers.h b/tests/clap/ext/draft/triggers.h new file mode 100644 index 0000000..bf85dee --- /dev/null +++ b/tests/clap/ext/draft/triggers.h @@ -0,0 +1,144 @@ +#pragma once + +#include "../../plugin.h" +#include "../../events.h" +#include "../../string-sizes.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_TRIGGERS[] = "clap.triggers/1"; + +#ifdef __cplusplus +extern "C" { +#endif + +/// @page Trigger events +/// +/// This extension enables the plugin to expose a set of triggers to the host. +/// +/// Some examples for triggers: +/// - trigger an envelope which is independent of the notes +/// - trigger a sample-and-hold unit (maybe even per-voice) + +enum { + // Does this trigger support per note automations? + CLAP_TRIGGER_IS_AUTOMATABLE_PER_NOTE_ID = 1 << 0, + + // Does this trigger support per key automations? + CLAP_TRIGGER_IS_AUTOMATABLE_PER_KEY = 1 << 1, + + // Does this trigger support per channel automations? + CLAP_TRIGGER_IS_AUTOMATABLE_PER_CHANNEL = 1 << 2, + + // Does this trigger support per port automations? + CLAP_TRIGGER_IS_AUTOMATABLE_PER_PORT = 1 << 3, +}; +typedef uint32_t clap_trigger_info_flags; + +// Given that this extension is still draft, it'll use the event-registry and its own event +// namespace until we stabilize it. +// +// #include +// +// uint16_t CLAP_EXT_TRIGGER_EVENT_SPACE_ID = UINT16_MAX; +// if (host_event_registry->query(host, CLAP_EXT_TRIGGERS, &CLAP_EXT_TRIGGER_EVENT_SPACE_ID)) { +// /* we can use trigger events */ +// } +// +// /* later on */ +// clap_event_trigger ev; +// ev.header.space_id = CLAP_EXT_TRIGGER_EVENT_SPACE_ID; +// ev.header.type = CLAP_EVENT_TRIGGER; + +enum { CLAP_EVENT_TRIGGER = 0 }; + +typedef struct clap_event_trigger { + clap_event_header_t header; + + // target trigger + clap_id trigger_id; // @ref clap_trigger_info.id + void *cookie; // @ref clap_trigger_info.cookie + + // target a specific note_id, port, key and channel, -1 for global + int32_t note_id; + int16_t port_index; + int16_t channel; + int16_t key; +} clap_event_trigger_t; + +/* This describes a trigger */ +typedef struct clap_trigger_info { + // stable trigger identifier, it must never change. + clap_id id; + + clap_trigger_info_flags flags; + + // in analogy to clap_param_info.cookie + void *cookie; + + // displayable name + char name[CLAP_NAME_SIZE]; + + // the module path containing the trigger, eg:"sequencers/seq1" + // '/' will be used as a separator to show a tree like structure. + char module[CLAP_PATH_SIZE]; +} clap_trigger_info_t; + +typedef struct clap_plugin_triggers { + // Returns the number of triggers. + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin); + + // Copies the trigger's info to trigger_info and returns true on success. + // [main-thread] + bool(CLAP_ABI *get_info)(const clap_plugin_t *plugin, + uint32_t index, + clap_trigger_info_t *trigger_info); +} clap_plugin_triggers_t; + +enum { + // The trigger info did change, use this flag for: + // - name change + // - module change + // New info takes effect immediately. + CLAP_TRIGGER_RESCAN_INFO = 1 << 0, + + // Invalidates everything the host knows about triggers. + // It can only be used while the plugin is deactivated. + // If the plugin is activated use clap_host->restart() and delay any change until the host calls + // clap_plugin->deactivate(). + // + // You must use this flag if: + // - some triggers were added or removed. + // - some triggers had critical changes: + // - is_per_note (flag) + // - is_per_key (flag) + // - is_per_channel (flag) + // - is_per_port (flag) + // - cookie + CLAP_TRIGGER_RESCAN_ALL = 1 << 1, +}; +typedef uint32_t clap_trigger_rescan_flags; + +enum { + // Clears all possible references to a trigger + CLAP_TRIGGER_CLEAR_ALL = 1 << 0, + + // Clears all automations to a trigger + CLAP_TRIGGER_CLEAR_AUTOMATIONS = 1 << 1, +}; +typedef uint32_t clap_trigger_clear_flags; + +typedef struct clap_host_triggers { + // Rescan the full list of triggers according to the flags. + // [main-thread] + void(CLAP_ABI *rescan)(const clap_host_t *host, clap_trigger_rescan_flags flags); + + // Clears references to a trigger. + // [main-thread] + void(CLAP_ABI *clear)(const clap_host_t *host, + clap_id trigger_id, + clap_trigger_clear_flags flags); +} clap_host_triggers_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/tuning.h b/tests/clap/ext/draft/tuning.h new file mode 100644 index 0000000..ae668b1 --- /dev/null +++ b/tests/clap/ext/draft/tuning.h @@ -0,0 +1,76 @@ +#pragma once + +#include "../../plugin.h" +#include "../../events.h" +#include "../../string-sizes.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_TUNING[] = "clap.tuning/2"; + +#ifdef __cplusplus +extern "C" { +#endif + +// Use clap_host_event_registry->query(host, CLAP_EXT_TUNING, &space_id) to know the event space. +// +// This event defines the tuning to be used on the given port/channel. +typedef struct clap_event_tuning { + clap_event_header_t header; + + int16_t port_index; // -1 global + int16_t channel; // 0..15, -1 global + clap_id tunning_id; +} clap_event_tuning_t; + +typedef struct clap_tuning_info { + clap_id tuning_id; + char name[CLAP_NAME_SIZE]; + bool is_dynamic; // true if the values may vary with time +} clap_tuning_info_t; + +typedef struct clap_plugin_tuning { + // Called when a tuning is added or removed from the pool. + // [main-thread] + void(CLAP_ABI *changed)(const clap_plugin_t *plugin); +} clap_plugin_tuning_t; + +// This extension provides a dynamic tuning table to the plugin. +typedef struct clap_host_tuning { + // Gets the relative tuning in semitones against equal temperament with A4=440Hz. + // The plugin may query the tuning at a rate that makes sense for *low* frequency modulations. + // + // If the tuning_id is not found or equals to CLAP_INVALID_ID, + // then the function shall gracefully return a sensible value. + // + // sample_offset is the sample offset from the beginning of the current process block. + // + // should_play(...) should be checked before calling this function. + // + // [audio-thread & in-process] + double(CLAP_ABI *get_relative)(const clap_host_t *host, + clap_id tuning_id, + int32_t channel, + int32_t key, + uint32_t sample_offset); + + // Returns true if the note should be played. + // [audio-thread & in-process] + bool(CLAP_ABI *should_play)(const clap_host_t *host, + clap_id tuning_id, + int32_t channel, + int32_t key); + + // Returns the number of tunings in the pool. + // [main-thread] + uint32_t(CLAP_ABI *get_tuning_count)(const clap_host_t *host); + + // Gets info about a tuning + // Returns true on success and stores the result into info. + // [main-thread] + bool(CLAP_ABI *get_info)(const clap_host_t *host, + uint32_t tuning_index, + clap_tuning_info_t *info); +} clap_host_tuning_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/draft/undo.h b/tests/clap/ext/draft/undo.h new file mode 100644 index 0000000..76070c3 --- /dev/null +++ b/tests/clap/ext/draft/undo.h @@ -0,0 +1,201 @@ +#pragma once + +#include "../../plugin.h" +#include "../../stream.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_UNDO[] = "clap.undo/4"; +static CLAP_CONSTEXPR const char CLAP_EXT_UNDO_CONTEXT[] = "clap.undo_context/4"; +static CLAP_CONSTEXPR const char CLAP_EXT_UNDO_DELTA[] = "clap.undo_delta/4"; + +#ifdef __cplusplus +extern "C" { +#endif + +/// @page Undo +/// +/// This extension enables the plugin to merge its undo history with the host. +/// This leads to a single undo history shared by the host and many plugins. +/// +/// Calling host->undo() or host->redo() is equivalent to clicking undo/redo within the host's GUI. +/// +/// If the plugin uses this interface then its undo and redo should be entirely delegated to +/// the host; clicking in the plugin's UI undo or redo is equivalent to clicking undo or redo in the +/// host's UI. +/// +/// Some changes are long running changes, for example a mouse interaction will begin editing some +/// complex data and it may take multiple events and a long duration to complete the change. +/// In such case the plugin will call host->begin_change() to indicate the beginning of a long +/// running change and complete the change by calling host->change_made(). +/// +/// The host may group changes together: +/// [---------------------------------] +/// ^-T0 ^-T1 ^-T2 ^-T3 +/// Here a long running change C0 begin at T0. +/// A instantaneous change C1 at T1, and another one C2 at T2. +/// Then at T3 the long running change is completed. +/// The host will then create a single undo step that will merge all the changes into C0. +/// +/// This leads to another important consideration: starting a long running change without +/// terminating is **VERY BAD**, because while a change is running it is impossible to call undo or +/// redo. +/// +/// Rationale: multiple designs were considered and this one has the benefit of having a single undo +/// history. This simplifies the host implementation, leading to less bugs, a more robust design +/// and maybe an easier experience for the user because there's a single undo context versus one +/// for the host and one for each plugin instance. +/// +/// This extension tries to make it as easy as possible for the plugin to hook into the host undo +/// and make it efficient when possible by using deltas. The plugin interfaces are all optional, and +/// the plugin can for a minimal implementation, just use the host interface and call +/// host->change_made() without providing a delta. This is enough for the host to know that it can +/// capture a plugin state for the undo step. + +typedef struct clap_undo_delta_properties { + // If true, then the plugin will provide deltas in host->change_made(). + // If false, then all clap_undo_delta_properties's attributes become irrelevant. + bool has_delta; + + // If true, then the deltas can be stored on disk and re-used in the future as long as the plugin + // is compatible with the given format_version. + // + // If false, then format_version must be set to CLAP_INVALID_ID. + bool are_deltas_persistent; + + // This represents the delta format version that the plugin is currently using. + // Use CLAP_INVALID_ID for invalid value. + clap_id format_version; +} clap_undo_delta_properties_t; + +// Use CLAP_EXT_UNDO_DELTA. +// This is an optional interface, using deltas is an optimization versus making a state snapshot. +typedef struct clap_plugin_undo_delta { + // Asks the plugin the delta properties. + // [main-thread] + void(CLAP_ABI *get_delta_properties)(const clap_plugin_t *plugin, + clap_undo_delta_properties_t *properties); + + // Asks the plugin if it can apply a delta using the given format version. + // Returns true if it is possible. + // [main-thread] + bool(CLAP_ABI *can_use_delta_format_version)(const clap_plugin_t *plugin, + clap_id format_version); + + // Undo using the delta. + // Returns true on success. + // + // [main-thread] + bool(CLAP_ABI *undo)(const clap_plugin_t *plugin, + clap_id format_version, + const void *delta, + size_t delta_size); + + // Redo using the delta. + // Returns true on success. + // + // [main-thread] + bool(CLAP_ABI *redo)(const clap_plugin_t *plugin, + clap_id format_version, + const void *delta, + size_t delta_size); +} clap_plugin_undo_delta_t; + +// Use CLAP_EXT_UNDO_CONTEXT. +// This is an optional interface, that the plugin can implement in order to know about +// the current undo context. +typedef struct clap_plugin_undo_context { + // Indicate if it is currently possible to perform an undo or redo operation. + // [main-thread & plugin-subscribed-to-undo-context] + void(CLAP_ABI *set_can_undo)(const clap_plugin_t *plugin, bool can_undo); + void(CLAP_ABI *set_can_redo)(const clap_plugin_t *plugin, bool can_redo); + + // Sets the name of the next undo or redo step. + // name: null terminated string. + // [main-thread & plugin-subscribed-to-undo-context] + void(CLAP_ABI *set_undo_name)(const clap_plugin_t *plugin, const char *name); + void(CLAP_ABI *set_redo_name)(const clap_plugin_t *plugin, const char *name); +} clap_plugin_undo_context_t; + +// Use CLAP_EXT_UNDO. +typedef struct clap_host_undo { + // Begins a long running change. + // The plugin must not call this twice: there must be either a call to cancel_change() or + // change_made() before calling begin_change() again. + // [main-thread] + void(CLAP_ABI *begin_change)(const clap_host_t *host); + + // Cancels a long running change. + // cancel_change() must not be called without a preceding begin_change(). + // [main-thread] + void(CLAP_ABI *cancel_change)(const clap_host_t *host); + + // Completes an undoable change. + // At the moment of this function call, plugin_state->save() would include the current change. + // + // name: mandatory null terminated string describing the change, this is displayed to the user + // + // delta: optional, it is a binary blobs used to perform the undo and redo. When not available + // the host will save the plugin state and use state->load() to perform undo and redo. + // The plugin must be able to perform a redo operation using the delta, though the undo operation + // is only possible if delta_can_undo is true. + // + // Note: the provided delta may be used for incremental state saving and crash recovery. The + // plugin can indicate a format version id and the validity lifetime for the binary blobs. + // The host can use these to verify the compatibility before applying the delta. + // If the plugin is unable to use a delta, a notification should be provided to the user and + // the crash recovery should perform a best effort job, at least restoring the latest saved + // state. + // + // Special case: for objects with shared and synchronized state, changes shouldn't be reported + // as the host already knows about it. + // For example, plugin parameter changes shouldn't produce a call to change_made(). + // + // Note: if the plugin asked for this interface, then host_state->mark_dirty() will not create an + // implicit undo step. + // + // Note: if the plugin did load a preset or did something that leads to a large delta, + // it may consider not producing a delta (pass null) and let the host make a state snapshot + // instead. + // + // Note: if a plugin is producing a lot of changes within a small amount of time, the host + // may merge them into a single undo step. + // + // [main-thread] + void(CLAP_ABI *change_made)(const clap_host_t *host, + const char *name, + const void *delta, + size_t delta_size, + bool delta_can_undo); + + // Asks the host to perform the next undo or redo step. + // + // Note: this maybe a complex and asynchronous operation, which may complete after + // this function returns. + // + // Note: the host may ignore this request if there is no undo/redo step to perform, + // or if the host is unable to perform undo/redo at the time (eg: a long running + // change is going on). + // + // [main-thread] + void(CLAP_ABI *request_undo)(const clap_host_t *host); + void(CLAP_ABI *request_redo)(const clap_host_t *host); + + // Subscribes to or unsubscribes from undo context info. + // + // This method helps reducing the number of calls the host has to perform when updating + // the undo context info. Consider a large project with 1000+ plugins, we don't want to + // call 1000+ times update, while the plugin may only need the context info if its GUI + // is shown and it wants to display undo/redo info. + // + // Initial state is unsubscribed. + // + // is_subscribed: set to true to receive context info + // + // It is mandatory for the plugin to implement CLAP_EXT_UNDO_CONTEXT when using this method. + // + // [main-thread] + void(CLAP_ABI *set_wants_context_updates)(const clap_host_t *host, bool is_subscribed); +} clap_host_undo_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/event-registry.h b/tests/clap/ext/event-registry.h new file mode 100644 index 0000000..c89cea4 --- /dev/null +++ b/tests/clap/ext/event-registry.h @@ -0,0 +1,22 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_EVENT_REGISTRY[] = "clap.event-registry"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_host_event_registry { + // Queries an event space id. + // The space id 0 is reserved for CLAP's core events. See CLAP_CORE_EVENT_SPACE. + // + // Return false and sets *space_id to UINT16_MAX if the space name is unknown to the host. + // [main-thread] + bool(CLAP_ABI *query)(const clap_host_t *host, const char *space_name, uint16_t *space_id); +} clap_host_event_registry_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/gui.h b/tests/clap/ext/gui.h new file mode 100644 index 0000000..d8d76ee --- /dev/null +++ b/tests/clap/ext/gui.h @@ -0,0 +1,244 @@ +#pragma once + +#include "../plugin.h" + +/// @page GUI +/// +/// This extension defines how the plugin will present its GUI. +/// +/// There are two approaches: +/// 1. the plugin creates a window and embeds it into the host's window +/// 2. the plugin creates a floating window +/// +/// Embedding the window gives more control to the host, and feels more integrated. +/// Floating window are sometimes the only option due to technical limitations. +/// +/// The Embedding protocol is by far the most common, supported by all hosts to date, +/// and a plugin author should support at least that case. +/// +/// Showing the GUI works as follow: +/// 1. clap_plugin_gui->is_api_supported(), check what can work +/// 2. clap_plugin_gui->create(), allocates gui resources +/// 3. if the plugin window is floating +/// 4. -> clap_plugin_gui->set_transient() +/// 5. -> clap_plugin_gui->suggest_title() +/// 6. else +/// 7. -> clap_plugin_gui->set_scale() +/// 8. -> clap_plugin_gui->can_resize() +/// 9. -> if resizable and has known size from previous session, clap_plugin_gui->set_size() +/// 10. -> else clap_plugin_gui->get_size(), gets initial size +/// 11. -> clap_plugin_gui->set_parent() +/// 12. clap_plugin_gui->show() +/// 13. clap_plugin_gui->hide()/show() ... +/// 14. clap_plugin_gui->destroy() when done with the gui +/// +/// Resizing the window (initiated by the plugin, if embedded): +/// 1. Plugins calls clap_host_gui->request_resize() +/// 2. If the host returns true the new size is accepted, +/// the host doesn't have to call clap_plugin_gui->set_size(). +/// If the host returns false, the new size is rejected. +/// +/// Resizing the window (drag, if embedded)): +/// 1. Only possible if clap_plugin_gui->can_resize() returns true +/// 2. Mouse drag -> new_size +/// 3. clap_plugin_gui->adjust_size(new_size) -> working_size +/// 4. clap_plugin_gui->set_size(working_size) + +static CLAP_CONSTEXPR const char CLAP_EXT_GUI[] = "clap.gui"; + +// If your windowing API is not listed here, please open an issue and we'll figure it out. +// https://github.com/free-audio/clap/issues/new + +// uses physical size +// embed using https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setparent +static const CLAP_CONSTEXPR char CLAP_WINDOW_API_WIN32[] = "win32"; + +// uses logical size, don't call clap_plugin_gui->set_scale() +static const CLAP_CONSTEXPR char CLAP_WINDOW_API_COCOA[] = "cocoa"; + +// uses physical size +// embed using https://specifications.freedesktop.org/xembed-spec/xembed-spec-latest.html +static const CLAP_CONSTEXPR char CLAP_WINDOW_API_X11[] = "x11"; + +// uses physical size +// embed is currently not supported, use floating windows +static const CLAP_CONSTEXPR char CLAP_WINDOW_API_WAYLAND[] = "wayland"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *clap_hwnd; +typedef void *clap_nsview; +typedef unsigned long clap_xwnd; + +// Represent a window reference. +typedef struct clap_window { + const char *api; // one of CLAP_WINDOW_API_XXX + union { + clap_nsview cocoa; + clap_xwnd x11; + clap_hwnd win32; + void *ptr; // for anything defined outside of clap + }; +} clap_window_t; + +// Information to improve window resizing when initiated by the host or window manager. +typedef struct clap_gui_resize_hints { + bool can_resize_horizontally; + bool can_resize_vertically; + + // if both horizontal and vertical resize are available, do we preserve the + // aspect ratio, and if so, what is the width x height aspect ratio to preserve. + // These flags are unused if can_resize_horizontally or vertically are false, + // and ratios are unused if preserve is false. + bool preserve_aspect_ratio; + uint32_t aspect_ratio_width; + uint32_t aspect_ratio_height; +} clap_gui_resize_hints_t; + +// Size (width, height) is in pixels; the corresponding windowing system extension is +// responsible for defining if it is physical pixels or logical pixels. +typedef struct clap_plugin_gui { + // Returns true if the requested gui api is supported, either in floating (plugin-created) + // or non-floating (embedded) mode. + // [main-thread] + bool(CLAP_ABI *is_api_supported)(const clap_plugin_t *plugin, const char *api, bool is_floating); + + // Returns true if the plugin has a preferred api. + // The host has no obligation to honor the plugin preference, this is just a hint. + // The const char **api variable should be explicitly assigned as a pointer to + // one of the CLAP_WINDOW_API_ constants defined above, not strcopied. + // [main-thread] + bool(CLAP_ABI *get_preferred_api)(const clap_plugin_t *plugin, + const char **api, + bool *is_floating); + + // Create and allocate all resources necessary for the gui. + // + // If is_floating is true, then the window will not be managed by the host. The plugin + // can set its window to stays above the parent window, see set_transient(). + // api may be null or blank for floating window. + // + // If is_floating is false, then the plugin has to embed its window into the parent window, see + // set_parent(). + // + // After this call, the GUI may not be visible yet; don't forget to call show(). + // + // Returns true if the GUI is successfully created. + // [main-thread] + bool(CLAP_ABI *create)(const clap_plugin_t *plugin, const char *api, bool is_floating); + + // Free all resources associated with the gui. + // [main-thread] + void(CLAP_ABI *destroy)(const clap_plugin_t *plugin); + + // Set the absolute GUI scaling factor, and override any OS info. + // Should not be used if the windowing api relies upon logical pixels. + // + // If the plugin prefers to work out the scaling factor itself by querying the OS directly, + // then ignore the call. + // + // scale = 2 means 200% scaling. + // + // Returns true if the scaling could be applied + // Returns false if the call was ignored, or the scaling could not be applied. + // [main-thread] + bool(CLAP_ABI *set_scale)(const clap_plugin_t *plugin, double scale); + + // Get the current size of the plugin UI. + // clap_plugin_gui->create() must have been called prior to asking the size. + // + // Returns true if the plugin could get the size. + // [main-thread] + bool(CLAP_ABI *get_size)(const clap_plugin_t *plugin, uint32_t *width, uint32_t *height); + + // Returns true if the window is resizeable (mouse drag). + // [main-thread & !floating] + bool(CLAP_ABI *can_resize)(const clap_plugin_t *plugin); + + // Returns true if the plugin can provide hints on how to resize the window. + // [main-thread & !floating] + bool(CLAP_ABI *get_resize_hints)(const clap_plugin_t *plugin, clap_gui_resize_hints_t *hints); + + // If the plugin gui is resizable, then the plugin will calculate the closest + // usable size which fits in the given size. + // This method does not change the size. + // + // Returns true if the plugin could adjust the given size. + // [main-thread & !floating] + bool(CLAP_ABI *adjust_size)(const clap_plugin_t *plugin, uint32_t *width, uint32_t *height); + + // Sets the window size. + // + // Returns true if the plugin could resize its window to the given size. + // [main-thread & !floating] + bool(CLAP_ABI *set_size)(const clap_plugin_t *plugin, uint32_t width, uint32_t height); + + // Embeds the plugin window into the given window. + // + // Returns true on success. + // [main-thread & !floating] + bool(CLAP_ABI *set_parent)(const clap_plugin_t *plugin, const clap_window_t *window); + + // Set the plugin floating window to stay above the given window. + // + // Returns true on success. + // [main-thread & floating] + bool(CLAP_ABI *set_transient)(const clap_plugin_t *plugin, const clap_window_t *window); + + // Suggests a window title. Only for floating windows. + // + // [main-thread & floating] + void(CLAP_ABI *suggest_title)(const clap_plugin_t *plugin, const char *title); + + // Show the window. + // + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *show)(const clap_plugin_t *plugin); + + // Hide the window, this method does not free the resources, it just hides + // the window content. Yet it may be a good idea to stop painting timers. + // + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *hide)(const clap_plugin_t *plugin); +} clap_plugin_gui_t; + +typedef struct clap_host_gui { + // The host should call get_resize_hints() again. + // [thread-safe & !floating] + void(CLAP_ABI *resize_hints_changed)(const clap_host_t *host); + + // Request the host to resize the client area to width, height. + // Return true if the new size is accepted, false otherwise. + // The host doesn't have to call set_size(). + // + // Note: if not called from the main thread, then a return value simply means that the host + // acknowledged the request and will process it asynchronously. If the request then can't be + // satisfied then the host will call set_size() to revert the operation. + // [thread-safe & !floating] + bool(CLAP_ABI *request_resize)(const clap_host_t *host, uint32_t width, uint32_t height); + + // Request the host to show the plugin gui. + // Return true on success, false otherwise. + // [thread-safe] + bool(CLAP_ABI *request_show)(const clap_host_t *host); + + // Request the host to hide the plugin gui. + // Return true on success, false otherwise. + // [thread-safe] + bool(CLAP_ABI *request_hide)(const clap_host_t *host); + + // The floating window has been closed, or the connection to the gui has been lost. + // + // If was_destroyed is true, then the host must call clap_plugin_gui->destroy() to acknowledge + // the gui destruction. + // [thread-safe] + void(CLAP_ABI *closed)(const clap_host_t *host, bool was_destroyed); +} clap_host_gui_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/latency.h b/tests/clap/ext/latency.h new file mode 100644 index 0000000..d10a132 --- /dev/null +++ b/tests/clap/ext/latency.h @@ -0,0 +1,27 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_LATENCY[] = "clap.latency"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_latency { + // Returns the plugin latency in samples. + // [main-thread & (being-activated | active)] + uint32_t(CLAP_ABI *get)(const clap_plugin_t *plugin); +} clap_plugin_latency_t; + +typedef struct clap_host_latency { + // Tell the host that the latency changed. + // The latency is only allowed to change during plugin->activate. + // If the plugin is activated, call host->request_restart() + // [main-thread & being-activated] + void(CLAP_ABI *changed)(const clap_host_t *host); +} clap_host_latency_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/log.h b/tests/clap/ext/log.h new file mode 100644 index 0000000..9609c6c --- /dev/null +++ b/tests/clap/ext/log.h @@ -0,0 +1,33 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_LOG[] = "clap.log"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + CLAP_LOG_DEBUG = 0, + CLAP_LOG_INFO = 1, + CLAP_LOG_WARNING = 2, + CLAP_LOG_ERROR = 3, + CLAP_LOG_FATAL = 4, + + // These severities should be used to report misbehaviour. + // The plugin one can be used by a layer between the plugin and the host. + CLAP_LOG_HOST_MISBEHAVING = 5, + CLAP_LOG_PLUGIN_MISBEHAVING = 6, +}; +typedef int32_t clap_log_severity; + +typedef struct clap_host_log { + // Log a message through the host. + // [thread-safe] + void(CLAP_ABI *log)(const clap_host_t *host, clap_log_severity severity, const char *msg); +} clap_host_log_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/note-name.h b/tests/clap/ext/note-name.h new file mode 100644 index 0000000..41e6a83 --- /dev/null +++ b/tests/clap/ext/note-name.h @@ -0,0 +1,37 @@ +#pragma once + +#include "../plugin.h" +#include "../string-sizes.h" + +#ifdef __cplusplus +extern "C" { +#endif + +static CLAP_CONSTEXPR const char CLAP_EXT_NOTE_NAME[] = "clap.note-name"; + +typedef struct clap_note_name { + char name[CLAP_NAME_SIZE]; + int16_t port; // -1 for every port + int16_t key; // -1 for every key + int16_t channel; // -1 for every channel +} clap_note_name_t; + +typedef struct clap_plugin_note_name { + // Return the number of note names + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin); + + // Returns true on success and stores the result into note_name + // [main-thread] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, uint32_t index, clap_note_name_t *note_name); +} clap_plugin_note_name_t; + +typedef struct clap_host_note_name { + // Informs the host that the note names have changed. + // [main-thread] + void(CLAP_ABI *changed)(const clap_host_t *host); +} clap_host_note_name_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/note-ports.h b/tests/clap/ext/note-ports.h new file mode 100644 index 0000000..f91b527 --- /dev/null +++ b/tests/clap/ext/note-ports.h @@ -0,0 +1,79 @@ +#pragma once + +#include "../plugin.h" +#include "../string-sizes.h" + +/// @page Note Ports +/// +/// This extension provides a way for the plugin to describe its current note ports. +/// If the plugin does not implement this extension, it won't have note input or output. +/// The plugin is only allowed to change its note ports configuration while it is deactivated. + +static CLAP_CONSTEXPR const char CLAP_EXT_NOTE_PORTS[] = "clap.note-ports"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum clap_note_dialect { + // Uses clap_event_note and clap_event_note_expression. + CLAP_NOTE_DIALECT_CLAP = 1 << 0, + + // Uses clap_event_midi, no polyphonic expression + CLAP_NOTE_DIALECT_MIDI = 1 << 1, + + // Uses clap_event_midi, with polyphonic expression (MPE) + CLAP_NOTE_DIALECT_MIDI_MPE = 1 << 2, + + // Uses clap_event_midi2 + CLAP_NOTE_DIALECT_MIDI2 = 1 << 3, +}; + +typedef struct clap_note_port_info { + // id identifies a port and must be stable. + // id may overlap between input and output ports. + clap_id id; + uint32_t supported_dialects; // bitfield, see clap_note_dialect + uint32_t preferred_dialect; // one value of clap_note_dialect + char name[CLAP_NAME_SIZE]; // displayable name, i18n? +} clap_note_port_info_t; + +// The note ports scan has to be done while the plugin is deactivated. +typedef struct clap_plugin_note_ports { + // Number of ports, for either input or output. + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin, bool is_input); + + // Get info about a note port. + // Returns true on success and stores the result into info. + // [main-thread] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, + uint32_t index, + bool is_input, + clap_note_port_info_t *info); +} clap_plugin_note_ports_t; + +enum { + // The ports have changed, the host shall perform a full scan of the ports. + // This flag can only be used if the plugin is not active. + // If the plugin active, call host->request_restart() and then call rescan() + // when the host calls deactivate() + CLAP_NOTE_PORTS_RESCAN_ALL = 1 << 0, + + // The ports name did change, the host can scan them right away. + CLAP_NOTE_PORTS_RESCAN_NAMES = 1 << 1, +}; + +typedef struct clap_host_note_ports { + // Query which dialects the host supports + // [main-thread] + uint32_t(CLAP_ABI *supported_dialects)(const clap_host_t *host); + + // Rescan the full list of note ports according to the flags. + // [main-thread] + void(CLAP_ABI *rescan)(const clap_host_t *host, uint32_t flags); +} clap_host_note_ports_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/param-indication.h b/tests/clap/ext/param-indication.h new file mode 100644 index 0000000..643a953 --- /dev/null +++ b/tests/clap/ext/param-indication.h @@ -0,0 +1,77 @@ +#pragma once + +#include "params.h" +#include "../color.h" + +// This extension lets the host tell the plugin to display a little color based indication on the +// parameter. This can be used to indicate: +// - a physical controller is mapped to a parameter +// - the parameter is current playing an automation +// - the parameter is overriding the automation +// - etc... +// +// The color semantic depends upon the host here and the goal is to have a consistent experience +// across all plugins. + +static CLAP_CONSTEXPR const char CLAP_EXT_PARAM_INDICATION[] = "clap.param-indication/4"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_PARAM_INDICATION_COMPAT[] = "clap.param-indication.draft/4"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // The host doesn't have an automation for this parameter + CLAP_PARAM_INDICATION_AUTOMATION_NONE = 0, + + // The host has an automation for this parameter, but it isn't playing it + CLAP_PARAM_INDICATION_AUTOMATION_PRESENT = 1, + + // The host is playing an automation for this parameter + CLAP_PARAM_INDICATION_AUTOMATION_PLAYING = 2, + + // The host is recording an automation on this parameter + CLAP_PARAM_INDICATION_AUTOMATION_RECORDING = 3, + + // The host should play an automation for this parameter, but the user has started to adjust this + // parameter and is overriding the automation playback + CLAP_PARAM_INDICATION_AUTOMATION_OVERRIDING = 4, +}; + +typedef struct clap_plugin_param_indication { + // Sets or clears a mapping indication. + // + // has_mapping: does the parameter currently has a mapping? + // color: if set, the color to use to highlight the control in the plugin GUI + // label: if set, a small string to display on top of the knob which identifies the hardware + // controller description: if set, a string which can be used in a tooltip, which describes the + // current mapping + // + // Parameter indications should not be saved in the plugin context, and are off by default. + // [main-thread] + void(CLAP_ABI *set_mapping)(const clap_plugin_t *plugin, + clap_id param_id, + bool has_mapping, + const clap_color_t *color, + const char *label, + const char *description); + + // Sets or clears an automation indication. + // + // automation_state: current automation state for the given parameter + // color: if set, the color to use to display the automation indication in the plugin GUI + // + // Parameter indications should not be saved in the plugin context, and are off by default. + // [main-thread] + void(CLAP_ABI *set_automation)(const clap_plugin_t *plugin, + clap_id param_id, + uint32_t automation_state, + const clap_color_t *color); +} clap_plugin_param_indication_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/params.h b/tests/clap/ext/params.h new file mode 100644 index 0000000..2f85769 --- /dev/null +++ b/tests/clap/ext/params.h @@ -0,0 +1,382 @@ +#pragma once + +#include "../plugin.h" +#include "../string-sizes.h" + +/// @page Parameters +/// @brief parameters management +/// +/// Main idea: +/// +/// The host sees the plugin as an atomic entity; and acts as a controller on top of its parameters. +/// The plugin is responsible for keeping its audio processor and its GUI in sync. +/// +/// The host can at any time read parameters' value on the [main-thread] using +/// @ref clap_plugin_params.get_value(). +/// +/// There are two options to communicate parameter value changes, and they are not concurrent. +/// - send automation points during clap_plugin.process() +/// - send automation points during clap_plugin_params.flush(), for parameter changes +/// without processing audio +/// +/// When the plugin changes a parameter value, it must inform the host. +/// It will send @ref CLAP_EVENT_PARAM_VALUE event during process() or flush(). +/// If the user is adjusting the value, don't forget to mark the beginning and end +/// of the gesture by sending CLAP_EVENT_PARAM_GESTURE_BEGIN and CLAP_EVENT_PARAM_GESTURE_END +/// events. +/// +/// @note MIDI CCs are tricky because you may not know when the parameter adjustment ends. +/// Also if the host records incoming MIDI CC and parameter change automation at the same time, +/// there will be a conflict at playback: MIDI CC vs Automation. +/// The parameter automation will always target the same parameter because the param_id is stable. +/// The MIDI CC may have a different mapping in the future and may result in a different playback. +/// +/// When a MIDI CC changes a parameter's value, set the flag CLAP_EVENT_DONT_RECORD in +/// clap_event_param.header.flags. That way the host may record the MIDI CC automation, but not the +/// parameter change and there won't be conflict at playback. +/// +/// Scenarios: +/// +/// I. Loading a preset +/// - load the preset in a temporary state +/// - call @ref clap_host_params.rescan() if anything changed +/// - call @ref clap_host_latency.changed() if latency changed +/// - invalidate any other info that may be cached by the host +/// - if the plugin is activated and the preset will introduce breaking changes +/// (latency, audio ports, new parameters, ...) be sure to wait for the host +/// to deactivate the plugin to apply those changes. +/// If there are no breaking changes, the plugin can apply them them right away. +/// The plugin is responsible for updating both its audio processor and its gui. +/// +/// II. Turning a knob on the DAW interface +/// - the host will send an automation event to the plugin via a process() or flush() +/// +/// III. Turning a knob on the Plugin interface +/// - the plugin is responsible for sending the parameter value to its audio processor +/// - call clap_host_params->request_flush() or clap_host->request_process(). +/// - when the host calls either clap_plugin->process() or clap_plugin_params->flush(), +/// send an automation event and don't forget to wrap the parameter change(s) +/// with CLAP_EVENT_PARAM_GESTURE_BEGIN and CLAP_EVENT_PARAM_GESTURE_END to define the +/// beginning and end of the gesture. +/// +/// IV. Turning a knob via automation +/// - host sends an automation point during clap_plugin->process() or clap_plugin_params->flush(). +/// - the plugin is responsible for updating its GUI +/// +/// V. Turning a knob via plugin's internal MIDI mapping +/// - the plugin sends a CLAP_EVENT_PARAM_VALUE output event, set should_record to false +/// - the plugin is responsible for updating its GUI +/// +/// VI. Adding or removing parameters +/// - if the plugin is activated call clap_host->restart() +/// - once the plugin isn't active: +/// - apply the new state +/// - if a parameter is gone or is created with an id that may have been used before, +/// call clap_host_params.clear(host, param_id, CLAP_PARAM_CLEAR_ALL) +/// - call clap_host_params->rescan(CLAP_PARAM_RESCAN_ALL) +/// +/// CLAP allows the plugin to change the parameter range, yet the plugin developer +/// should be aware that doing so isn't without risk, especially if you made the +/// promise to never change the sound. If you want to be 100% certain that the +/// sound will not change with all host, then simply never change the range. +/// +/// There are two approaches to automations, either you automate the plain value, +/// or you automate the knob position. The first option will be robust to a range +/// increase, while the second won't be. +/// +/// If the host goes with the second approach (automating the knob position), it means +/// that the plugin is hosted in a relaxed environment regarding sound changes (they are +/// accepted, and not a concern as long as they are reasonable). Though, stepped parameters +/// should be stored as plain value in the document. +/// +/// If the host goes with the first approach, there will still be situation where the +/// sound may inevitably change. For example, if the plugin increase the range, there +/// is an automation playing at the max value and on top of that an LFO is applied. +/// See the following curve: +/// . +/// . . +/// ..... . . +/// before: . . and after: . . +/// +/// Persisting parameter values: +/// +/// Plugins are responsible for persisting their parameter's values between +/// sessions by implementing the state extension. Otherwise parameter value will +/// not be recalled when reloading a project. Hosts should _not_ try to save and +/// restore parameter values for plugins that don't implement the state +/// extension. +/// +/// Advice for the host: +/// +/// - store plain values in the document (automation) +/// - store modulation amount in plain value delta, not in percentage +/// - when you apply a CC mapping, remember the min/max plain values so you can adjust +/// - do not implement a parameter saving fall back for plugins that don't +/// implement the state extension +/// +/// Advice for the plugin: +/// +/// - think carefully about your parameter range when designing your DSP +/// - avoid shrinking parameter ranges, they are very likely to change the sound +/// - consider changing the parameter range as a tradeoff: what you improve vs what you break +/// - make sure to implement saving and loading the parameter values using the +/// state extension +/// - if you plan to use adapters for other plugin formats, then you need to pay extra +/// attention to the adapter requirements + +static CLAP_CONSTEXPR const char CLAP_EXT_PARAMS[] = "clap.params"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // Is this param stepped? (integer values only) + // if so the double value is converted to integer using a cast (equivalent to trunc). + CLAP_PARAM_IS_STEPPED = 1 << 0, + + // Useful for periodic parameters like a phase + CLAP_PARAM_IS_PERIODIC = 1 << 1, + + // The parameter should not be shown to the user, because it is currently not used. + // It is not necessary to process automation for this parameter. + CLAP_PARAM_IS_HIDDEN = 1 << 2, + + // The parameter can't be changed by the host. + CLAP_PARAM_IS_READONLY = 1 << 3, + + // This parameter is used to merge the plugin and host bypass button. + // It implies that the parameter is stepped. + // min: 0 -> bypass off + // max: 1 -> bypass on + CLAP_PARAM_IS_BYPASS = 1 << 4, + + // When set: + // - automation can be recorded + // - automation can be played back + // + // The host can send live user changes for this parameter regardless of this flag. + // + // If this parameter affects the internal processing structure of the plugin, ie: max delay, fft + // size, ... and the plugins needs to re-allocate its working buffers, then it should call + // host->request_restart(), and perform the change once the plugin is re-activated. + CLAP_PARAM_IS_AUTOMATABLE = 1 << 5, + + // Does this parameter support per note automations? + CLAP_PARAM_IS_AUTOMATABLE_PER_NOTE_ID = 1 << 6, + + // Does this parameter support per key automations? + CLAP_PARAM_IS_AUTOMATABLE_PER_KEY = 1 << 7, + + // Does this parameter support per channel automations? + CLAP_PARAM_IS_AUTOMATABLE_PER_CHANNEL = 1 << 8, + + // Does this parameter support per port automations? + CLAP_PARAM_IS_AUTOMATABLE_PER_PORT = 1 << 9, + + // Does this parameter support the modulation signal? + CLAP_PARAM_IS_MODULATABLE = 1 << 10, + + // Does this parameter support per note modulations? + CLAP_PARAM_IS_MODULATABLE_PER_NOTE_ID = 1 << 11, + + // Does this parameter support per key modulations? + CLAP_PARAM_IS_MODULATABLE_PER_KEY = 1 << 12, + + // Does this parameter support per channel modulations? + CLAP_PARAM_IS_MODULATABLE_PER_CHANNEL = 1 << 13, + + // Does this parameter support per port modulations? + CLAP_PARAM_IS_MODULATABLE_PER_PORT = 1 << 14, + + // Any change to this parameter will affect the plugin output and requires to be done via + // process() if the plugin is active. + // + // A simple example would be a DC Offset, changing it will change the output signal and must be + // processed. + CLAP_PARAM_REQUIRES_PROCESS = 1 << 15, + + // This parameter represents an enumerated value. + // If you set this flag, then you must set CLAP_PARAM_IS_STEPPED too. + // All values from min to max must not have a blank value_to_text(). + CLAP_PARAM_IS_ENUM = 1 << 16, +}; +typedef uint32_t clap_param_info_flags; + +/* This describes a parameter */ +typedef struct clap_param_info { + // Stable parameter identifier, it must never change. + clap_id id; + + clap_param_info_flags flags; + + // This value is optional and set by the plugin. + // Its purpose is to provide fast access to the plugin parameter object by caching its pointer. + // For instance: + // + // in clap_plugin_params.get_info(): + // Parameter *p = findParameter(param_id); + // param_info->cookie = p; + // + // later, in clap_plugin.process(): + // + // Parameter *p = (Parameter *)event->cookie; + // if (!p) [[unlikely]] + // p = findParameter(event->param_id); + // + // where findParameter() is a function the plugin implements to map parameter ids to internal + // objects. + // + // Important: + // - The cookie is invalidated by a call to clap_host_params->rescan(CLAP_PARAM_RESCAN_ALL) or + // when the plugin is destroyed. + // - The host will either provide the cookie as issued or nullptr in events addressing + // parameters. + // - The plugin must gracefully handle the case of a cookie which is nullptr. + // - Many plugins will process the parameter events more quickly if the host can provide the + // cookie in a faster time than a hashmap lookup per param per event. + void *cookie; + + // The display name. eg: "Volume". This does not need to be unique. Do not include the module + // text in this. The host should concatenate/format the module + name in the case where showing + // the name alone would be too vague. + char name[CLAP_NAME_SIZE]; + + // The module path containing the param, eg: "Oscillators/Wavetable 1". + // '/' will be used as a separator to show a tree-like structure. + char module[CLAP_PATH_SIZE]; + + double min_value; // Minimum plain value. Must be finite (`std::isfinite` true) + double max_value; // Maximum plain value. Must be finite + double default_value; // Default plain value. Must be in [min, max] range. +} clap_param_info_t; + +typedef struct clap_plugin_params { + // Returns the number of parameters. + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin); + + // Copies the parameter's info to param_info. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *get_info)(const clap_plugin_t *plugin, + uint32_t param_index, + clap_param_info_t *param_info); + + // Writes the parameter's current value to out_value. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *get_value)(const clap_plugin_t *plugin, clap_id param_id, double *out_value); + + // Fills out_buffer with a null-terminated UTF-8 string that represents the parameter at the + // given 'value' argument. eg: "2.3 kHz". The host should always use this to format parameter + // values before displaying it to the user. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *value_to_text)(const clap_plugin_t *plugin, + clap_id param_id, + double value, + char *out_buffer, + uint32_t out_buffer_capacity); + + // Converts the null-terminated UTF-8 param_value_text into a double and writes it to out_value. + // The host can use this to convert user input into a parameter value. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *text_to_value)(const clap_plugin_t *plugin, + clap_id param_id, + const char *param_value_text, + double *out_value); + + // Flushes a set of parameter changes. + // This method must not be called concurrently to clap_plugin->process(). + // + // Note: if the plugin is processing, then the process() call will already achieve the + // parameter update (bi-directional), so a call to flush isn't required, also be aware + // that the plugin may use the sample offset in process(), while this information would be + // lost within flush(). + // + // [active ? audio-thread : main-thread] + void(CLAP_ABI *flush)(const clap_plugin_t *plugin, + const clap_input_events_t *in, + const clap_output_events_t *out); +} clap_plugin_params_t; + +enum { + // The parameter values did change, eg. after loading a preset. + // The host will scan all the parameters value. + // The host will not record those changes as automation points. + // New values takes effect immediately. + CLAP_PARAM_RESCAN_VALUES = 1 << 0, + + // The value to text conversion changed, and the text needs to be rendered again. + CLAP_PARAM_RESCAN_TEXT = 1 << 1, + + // The parameter info did change, use this flag for: + // - name change + // - module change + // - is_periodic (flag) + // - is_hidden (flag) + // New info takes effect immediately. + CLAP_PARAM_RESCAN_INFO = 1 << 2, + + // Invalidates everything the host knows about parameters. + // It can only be used while the plugin is deactivated. + // If the plugin is activated use clap_host->restart() and delay any change until the host calls + // clap_plugin->deactivate(). + // + // You must use this flag if: + // - some parameters were added or removed. + // - some parameters had critical changes: + // - is_per_note (flag) + // - is_per_key (flag) + // - is_per_channel (flag) + // - is_per_port (flag) + // - is_readonly (flag) + // - is_bypass (flag) + // - is_stepped (flag) + // - is_modulatable (flag) + // - min_value + // - max_value + // - cookie + CLAP_PARAM_RESCAN_ALL = 1 << 3, +}; +typedef uint32_t clap_param_rescan_flags; + +enum { + // Clears all possible references to a parameter + CLAP_PARAM_CLEAR_ALL = 1 << 0, + + // Clears all automations to a parameter + CLAP_PARAM_CLEAR_AUTOMATIONS = 1 << 1, + + // Clears all modulations to a parameter + CLAP_PARAM_CLEAR_MODULATIONS = 1 << 2, +}; +typedef uint32_t clap_param_clear_flags; + +typedef struct clap_host_params { + // Rescan the full list of parameters according to the flags. + // [main-thread] + void(CLAP_ABI *rescan)(const clap_host_t *host, clap_param_rescan_flags flags); + + // Clears references to a parameter. + // [main-thread] + void(CLAP_ABI *clear)(const clap_host_t *host, clap_id param_id, clap_param_clear_flags flags); + + // Request a parameter flush. + // + // The host will then schedule a call to either: + // - clap_plugin.process() + // - clap_plugin_params.flush() + // + // This function is always safe to use and should not be called from an [audio-thread] as the + // plugin would already be within process() or flush(). + // + // [thread-safe,!audio-thread] + void(CLAP_ABI *request_flush)(const clap_host_t *host); +} clap_host_params_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/posix-fd-support.h b/tests/clap/ext/posix-fd-support.h new file mode 100644 index 0000000..c713ec8 --- /dev/null +++ b/tests/clap/ext/posix-fd-support.h @@ -0,0 +1,49 @@ +#pragma once + +#include "../plugin.h" + +// This extension let your plugin hook itself into the host select/poll/epoll/kqueue reactor. +// This is useful to handle asynchronous I/O on the main thread. +static CLAP_CONSTEXPR const char CLAP_EXT_POSIX_FD_SUPPORT[] = "clap.posix-fd-support"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // IO events flags, they can be used to form a mask which describes: + // - which events you are interested in (register_fd/modify_fd) + // - which events happened (on_fd) + CLAP_POSIX_FD_READ = 1 << 0, + CLAP_POSIX_FD_WRITE = 1 << 1, + CLAP_POSIX_FD_ERROR = 1 << 2, +}; +typedef uint32_t clap_posix_fd_flags_t; + +typedef struct clap_plugin_posix_fd_support { + // This callback is "level-triggered". + // It means that a writable fd will continuously produce "on_fd()" events; + // don't forget using modify_fd() to remove the write notification once you're + // done writing. + // + // [main-thread] + void(CLAP_ABI *on_fd)(const clap_plugin_t *plugin, int fd, clap_posix_fd_flags_t flags); +} clap_plugin_posix_fd_support_t; + +typedef struct clap_host_posix_fd_support { + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *register_fd)(const clap_host_t *host, int fd, clap_posix_fd_flags_t flags); + + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *modify_fd)(const clap_host_t *host, int fd, clap_posix_fd_flags_t flags); + + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *unregister_fd)(const clap_host_t *host, int fd); +} clap_host_posix_fd_support_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/preset-load.h b/tests/clap/ext/preset-load.h new file mode 100644 index 0000000..1e4122e --- /dev/null +++ b/tests/clap/ext/preset-load.h @@ -0,0 +1,53 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_PRESET_LOAD[] = "clap.preset-load/2"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_PRESET_LOAD_COMPAT[] = "clap.preset-load.draft/2"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_preset_load { + // Loads a preset in the plugin native preset file format from a location. + // The preset discovery provider defines the location and load_key to be passed to this function. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *from_location)(const clap_plugin_t *plugin, + uint32_t location_kind, + const char *location, + const char *load_key); +} clap_plugin_preset_load_t; + +typedef struct clap_host_preset_load { + // Called if clap_plugin_preset_load.load() failed. + // os_error: the operating system error, if applicable. If not applicable set it to a non-error + // value, eg: 0 on unix and Windows. + // + // [main-thread] + void(CLAP_ABI *on_error)(const clap_host_t *host, + uint32_t location_kind, + const char *location, + const char *load_key, + int32_t os_error, + const char *msg); + + // Informs the host that the following preset has been loaded. + // This contributes to keep in sync the host preset browser and plugin preset browser. + // If the preset was loaded from a container file, then the load_key must be set, otherwise it + // must be null. + // + // [main-thread] + void(CLAP_ABI *loaded)(const clap_host_t *host, + uint32_t location_kind, + const char *location, + const char *load_key); +} clap_host_preset_load_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/remote-controls.h b/tests/clap/ext/remote-controls.h new file mode 100644 index 0000000..d7bf4fc --- /dev/null +++ b/tests/clap/ext/remote-controls.h @@ -0,0 +1,83 @@ +#pragma once + +#include "../plugin.h" +#include "../string-sizes.h" + +// This extension let the plugin provide a structured way of mapping parameters to an hardware +// controller. +// +// This is done by providing a set of remote control pages organized by section. +// A page contains up to 8 controls, which references parameters using param_id. +// +// |`- [section:main] +// | `- [name:main] performance controls +// |`- [section:osc] +// | |`- [name:osc1] osc1 page +// | |`- [name:osc2] osc2 page +// | |`- [name:osc-sync] osc sync page +// | `- [name:osc-noise] osc noise page +// |`- [section:filter] +// | |`- [name:flt1] filter 1 page +// | `- [name:flt2] filter 2 page +// |`- [section:env] +// | |`- [name:env1] env1 page +// | `- [name:env2] env2 page +// |`- [section:lfo] +// | |`- [name:lfo1] env1 page +// | `- [name:lfo2] env2 page +// `- etc... +// +// One possible workflow is to have a set of buttons, which correspond to a section. +// Pressing that button once gets you to the first page of the section. +// Press it again to cycle through the section's pages. + +static CLAP_CONSTEXPR const char CLAP_EXT_REMOTE_CONTROLS[] = "clap.remote-controls/2"; + +// The latest draft is 100% compatible +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_REMOTE_CONTROLS_COMPAT[] = "clap.remote-controls.draft/2"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { CLAP_REMOTE_CONTROLS_COUNT = 8 }; + +typedef struct clap_remote_controls_page { + char section_name[CLAP_NAME_SIZE]; + clap_id page_id; + char page_name[CLAP_NAME_SIZE]; + clap_id param_ids[CLAP_REMOTE_CONTROLS_COUNT]; + + // This is used to separate device pages versus preset pages. + // If true, then this page is specific to this preset. + bool is_for_preset; +} clap_remote_controls_page_t; + +typedef struct clap_plugin_remote_controls { + // Returns the number of pages. + // [main-thread] + uint32_t(CLAP_ABI *count)(const clap_plugin_t *plugin); + + // Get a page by index. + // Returns true on success and stores the result into page. + // [main-thread] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, + uint32_t page_index, + clap_remote_controls_page_t *page); +} clap_plugin_remote_controls_t; + +typedef struct clap_host_remote_controls { + // Informs the host that the remote controls have changed. + // [main-thread] + void(CLAP_ABI *changed)(const clap_host_t *host); + + // Suggest a page to the host because it corresponds to what the user is currently editing in the + // plugin's GUI. + // [main-thread] + void(CLAP_ABI *suggest_page)(const clap_host_t *host, clap_id page_id); +} clap_host_remote_controls_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/render.h b/tests/clap/ext/render.h new file mode 100644 index 0000000..0e1c1cd --- /dev/null +++ b/tests/clap/ext/render.h @@ -0,0 +1,39 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_RENDER[] = "clap.render"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // Default setting, for "realtime" processing + CLAP_RENDER_REALTIME = 0, + + // For processing without realtime pressure + // The plugin may use more expensive algorithms for higher sound quality. + CLAP_RENDER_OFFLINE = 1, +}; +typedef int32_t clap_plugin_render_mode; + +// The render extension is used to let the plugin know if it has "realtime" +// pressure to process. +// +// If this information does not influence your rendering code, then don't +// implement this extension. +typedef struct clap_plugin_render { + // Returns true if the plugin has a hard requirement to process in real-time. + // This is especially useful for plugin acting as a proxy to an hardware device. + // [main-thread] + bool(CLAP_ABI *has_hard_realtime_requirement)(const clap_plugin_t *plugin); + + // Returns true if the rendering mode could be applied. + // [main-thread] + bool(CLAP_ABI *set)(const clap_plugin_t *plugin, clap_plugin_render_mode mode); +} clap_plugin_render_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/state-context.h b/tests/clap/ext/state-context.h new file mode 100644 index 0000000..20248b3 --- /dev/null +++ b/tests/clap/ext/state-context.h @@ -0,0 +1,72 @@ +#pragma once + +#include "../plugin.h" +#include "../stream.h" + +/// @page state-context extension +/// @brief extended state handling +/// +/// This extension lets the host save and load the plugin state with different semantics depending +/// on the context. +/// +/// Briefly, when loading a preset or duplicating a device, the plugin may want to partially load +/// the state and initialize certain things differently, like handling limited resources or fixed +/// connections to external hardware resources. +/// +/// Save and Load operations may have a different context. +/// All three operations should be equivalent: +/// 1. clap_plugin_state_context.load(clap_plugin_state.save(), CLAP_STATE_CONTEXT_FOR_PRESET) +/// 2. clap_plugin_state.load(clap_plugin_state_context.save(CLAP_STATE_CONTEXT_FOR_PRESET)) +/// 3. clap_plugin_state_context.load( +/// clap_plugin_state_context.save(CLAP_STATE_CONTEXT_FOR_PRESET), +/// CLAP_STATE_CONTEXT_FOR_PRESET) +/// +/// If in doubt, fallback to clap_plugin_state. +/// +/// If the plugin implements CLAP_EXT_STATE_CONTEXT then it is mandatory to also implement +/// CLAP_EXT_STATE. +/// +/// It is unspecified which context is equivalent to clap_plugin_state.{save,load}() + +#ifdef __cplusplus +extern "C" { +#endif + +static CLAP_CONSTEXPR const char CLAP_EXT_STATE_CONTEXT[] = "clap.state-context/2"; + +enum clap_plugin_state_context_type { + // suitable for storing and loading a state as a preset + CLAP_STATE_CONTEXT_FOR_PRESET = 1, + + // suitable for duplicating a plugin instance + CLAP_STATE_CONTEXT_FOR_DUPLICATE = 2, + + // suitable for storing and loading a state within a project/song + CLAP_STATE_CONTEXT_FOR_PROJECT = 3, +}; + +typedef struct clap_plugin_state_context { + // Saves the plugin state into stream, according to context_type. + // Returns true if the state was correctly saved. + // + // Note that the result may be loaded by both clap_plugin_state.load() and + // clap_plugin_state_context.load(). + // [main-thread] + bool(CLAP_ABI *save)(const clap_plugin_t *plugin, + const clap_ostream_t *stream, + uint32_t context_type); + + // Loads the plugin state from stream, according to context_type. + // Returns true if the state was correctly restored. + // + // Note that the state may have been saved by clap_plugin_state.save() or + // clap_plugin_state_context.save() with a different context_type. + // [main-thread] + bool(CLAP_ABI *load)(const clap_plugin_t *plugin, + const clap_istream_t *stream, + uint32_t context_type); +} clap_plugin_state_context_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/state.h b/tests/clap/ext/state.h new file mode 100644 index 0000000..540246b --- /dev/null +++ b/tests/clap/ext/state.h @@ -0,0 +1,45 @@ +#pragma once + +#include "../plugin.h" +#include "../stream.h" + +/// @page State +/// @brief state management +/// +/// Plugins can implement this extension to save and restore both parameter +/// values and non-parameter state. This is used to persist a plugin's state +/// between project reloads, when duplicating and copying plugin instances, and +/// for host-side preset management. +/// +/// If you need to know if the save/load operation is meant for duplicating a plugin +/// instance, for saving/loading a plugin preset or while saving/loading the project +/// then consider implementing CLAP_EXT_STATE_CONTEXT in addition to CLAP_EXT_STATE. + +static CLAP_CONSTEXPR const char CLAP_EXT_STATE[] = "clap.state"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_state { + // Saves the plugin state into stream. + // Returns true if the state was correctly saved. + // [main-thread] + bool(CLAP_ABI *save)(const clap_plugin_t *plugin, const clap_ostream_t *stream); + + // Loads the plugin state from stream. + // Returns true if the state was correctly restored. + // [main-thread] + bool(CLAP_ABI *load)(const clap_plugin_t *plugin, const clap_istream_t *stream); +} clap_plugin_state_t; + +typedef struct clap_host_state { + // Tell the host that the plugin state has changed and should be saved again. + // If a parameter value changes, then it is implicit that the state is dirty. + // [main-thread] + void(CLAP_ABI *mark_dirty)(const clap_host_t *host); +} clap_host_state_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/surround.h b/tests/clap/ext/surround.h new file mode 100644 index 0000000..85956c1 --- /dev/null +++ b/tests/clap/ext/surround.h @@ -0,0 +1,89 @@ +#pragma once + +#include "../plugin.h" + +// This extension can be used to specify the channel mapping used by the plugin. +// +// To have consistent surround features across all the plugin instances, +// here is the proposed workflow: +// 1. the plugin queries the host preferred channel mapping and +// adjusts its configuration to match it. +// 2. the host checks how the plugin is effectively configured and honors it. +// +// If the host decides to change the project's surround setup: +// 1. deactivate the plugin +// 2. host calls clap_plugin_surround->changed() +// 3. plugin calls clap_host_surround->get_preferred_channel_map() +// 4. plugin eventually calls clap_host_surround->changed() +// 5. host calls clap_plugin_surround->get_channel_map() if changed +// 6. host activates the plugin and can start processing audio +// +// If the plugin wants to change its surround setup: +// 1. call host->request_restart() if the plugin is active +// 2. once deactivated plugin calls clap_host_surround->changed() +// 3. host calls clap_plugin_surround->get_channel_map() +// 4. host activates the plugin and can start processing audio + +static CLAP_CONSTEXPR const char CLAP_EXT_SURROUND[] = "clap.surround/4"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_SURROUND_COMPAT[] = "clap.surround.draft/4"; + +static CLAP_CONSTEXPR const char CLAP_PORT_SURROUND[] = "surround"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + CLAP_SURROUND_FL = 0, // Front Left + CLAP_SURROUND_FR = 1, // Front Right + CLAP_SURROUND_FC = 2, // Front Center + CLAP_SURROUND_LFE = 3, // Low Frequency + CLAP_SURROUND_BL = 4, // Back (Rear) Left + CLAP_SURROUND_BR = 5, // Back (Rear) Right + CLAP_SURROUND_FLC = 6, // Front Left of Center + CLAP_SURROUND_FRC = 7, // Front Right of Center + CLAP_SURROUND_BC = 8, // Back (Rear) Center + CLAP_SURROUND_SL = 9, // Side Left + CLAP_SURROUND_SR = 10, // Side Right + CLAP_SURROUND_TC = 11, // Top (Height) Center + CLAP_SURROUND_TFL = 12, // Top (Height) Front Left + CLAP_SURROUND_TFC = 13, // Top (Height) Front Center + CLAP_SURROUND_TFR = 14, // Top (Height) Front Right + CLAP_SURROUND_TBL = 15, // Top (Height) Back (Rear) Left + CLAP_SURROUND_TBC = 16, // Top (Height) Back (Rear) Center + CLAP_SURROUND_TBR = 17, // Top (Height) Back (Rear) Right + CLAP_SURROUND_TSL = 18, // Top (Height) Side Left + CLAP_SURROUND_TSR = 19, // Top (Height) Side Right +}; + +typedef struct clap_plugin_surround { + // Checks if a given channel mask is supported. + // The channel mask is a bitmask, for example: + // (1 << CLAP_SURROUND_FL) | (1 << CLAP_SURROUND_FR) | ... + // [main-thread] + bool(CLAP_ABI *is_channel_mask_supported)(const clap_plugin_t *plugin, uint64_t channel_mask); + + // Stores the surround identifier of each channel into the channel_map array. + // Returns the number of elements stored in channel_map. + // channel_map_capacity must be greater or equal to the channel count of the given port. + // [main-thread] + uint32_t(CLAP_ABI *get_channel_map)(const clap_plugin_t *plugin, + bool is_input, + uint32_t port_index, + uint8_t *channel_map, + uint32_t channel_map_capacity); +} clap_plugin_surround_t; + +typedef struct clap_host_surround { + // Informs the host that the channel map has changed. + // The channel map can only change when the plugin is de-activated. + // [main-thread] + void(CLAP_ABI *changed)(const clap_host_t *host); +} clap_host_surround_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/tail.h b/tests/clap/ext/tail.h new file mode 100644 index 0000000..5d79e3a --- /dev/null +++ b/tests/clap/ext/tail.h @@ -0,0 +1,26 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_TAIL[] = "clap.tail"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_tail { + // Returns tail length in samples. + // Any value greater or equal to INT32_MAX implies infinite tail. + // [main-thread,audio-thread] + uint32_t(CLAP_ABI *get)(const clap_plugin_t *plugin); +} clap_plugin_tail_t; + +typedef struct clap_host_tail { + // Tell the host that the tail has changed. + // [audio-thread] + void(CLAP_ABI *changed)(const clap_host_t *host); +} clap_host_tail_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/thread-check.h b/tests/clap/ext/thread-check.h new file mode 100644 index 0000000..876df97 --- /dev/null +++ b/tests/clap/ext/thread-check.h @@ -0,0 +1,72 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_THREAD_CHECK[] = "clap.thread-check"; + +#ifdef __cplusplus +extern "C" { +#endif + +/// @page thread-check +/// +/// CLAP defines two symbolic threads: +/// +/// main-thread: +/// This is the thread in which most of the interaction between the plugin and host happens. +/// This will be the same OS thread throughout the lifetime of the plug-in. +/// On macOS and Windows, this must be the thread on which gui and timer events are received +/// (i.e., the main thread of the program). +/// It isn't a realtime thread, yet this thread needs to respond fast enough to allow responsive +/// user interaction, so it is strongly recommended plugins run long,and expensive or blocking +/// tasks such as preset indexing or asset loading in dedicated background threads started by the +/// plugin. +/// +/// audio-thread: +/// This thread can be used for realtime audio processing. Its execution should be as +/// deterministic as possible to meet the audio interface's deadline (can be <1ms). There are a +/// known set of operations that should be avoided: malloc() and free(), contended locks and +/// mutexes, I/O, waiting, and so forth. +/// +/// The audio-thread is symbolic, there isn't one OS thread that remains the +/// audio-thread for the plugin lifetime. A host is may opt to have a +/// thread pool and the plugin.process() call may be scheduled on different OS threads over time. +/// However, the host must guarantee that single plugin instance will not be two audio-threads +/// at the same time. +/// +/// Functions marked with [audio-thread] **ARE NOT CONCURRENT**. The host may mark any OS thread, +/// including the main-thread as the audio-thread, as long as it can guarantee that only one OS +/// thread is the audio-thread at a time in a plugin instance. The audio-thread can be seen as a +/// concurrency guard for all functions marked with [audio-thread]. +/// +/// The real-time constraint on the [audio-thread] interacts closely with the render extension. +/// If a plugin doesn't implement render, then that plugin must have all [audio-thread] functions +/// meet the real time standard. If the plugin does implement render, and returns true when +/// render mode is set to real-time or if the plugin advertises a hard realtime requirement, it +/// must implement realtime constraints. Hosts also provide functions marked [audio-thread]. +/// These can be safely called by a plugin in the audio thread. Therefore hosts must either (1) +/// implement those functions meeting the real-time constraints or (2) not process plugins which +/// advertise a hard realtime constraint or don't implement the render extension. Hosts which +/// provide [audio-thread] functions outside these conditions may experience inconsistent or +/// inaccurate rendering. +/// +/// Clap also tags some functions as [thread-safe]. Functions tagged as [thread-safe] can be called +/// from any thread unless explicitly counter-indicated (for instance [thread-safe, !audio-thread]) +/// and may be called concurrently. + +// This interface is useful to do runtime checks and make +// sure that the functions are called on the correct threads. +// It is highly recommended that hosts implement this extension. +typedef struct clap_host_thread_check { + // Returns true if "this" thread is the main thread. + // [thread-safe] + bool(CLAP_ABI *is_main_thread)(const clap_host_t *host); + + // Returns true if "this" thread is one of the audio threads. + // [thread-safe] + bool(CLAP_ABI *is_audio_thread)(const clap_host_t *host); +} clap_host_thread_check_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/thread-pool.h b/tests/clap/ext/thread-pool.h new file mode 100644 index 0000000..790bef9 --- /dev/null +++ b/tests/clap/ext/thread-pool.h @@ -0,0 +1,66 @@ +#pragma once + +#include "../plugin.h" + +/// @page +/// +/// This extension lets the plugin use the host's thread pool. +/// +/// The plugin must provide @ref clap_plugin_thread_pool, and the host may provide @ref +/// clap_host_thread_pool. If it doesn't, the plugin should process its data by its own means. In +/// the worst case, a single threaded for-loop. +/// +/// Simple example with N voices to process +/// +/// @code +/// void myplug_thread_pool_exec(const clap_plugin *plugin, uint32_t voice_index) +/// { +/// compute_voice(plugin, voice_index); +/// } +/// +/// void myplug_process(const clap_plugin *plugin, const clap_process *process) +/// { +/// ... +/// bool didComputeVoices = false; +/// if (host_thread_pool && host_thread_pool.exec) +/// didComputeVoices = host_thread_pool.request_exec(host, plugin, N); +/// +/// if (!didComputeVoices) +/// for (uint32_t i = 0; i < N; ++i) +/// myplug_thread_pool_exec(plugin, i); +/// ... +/// } +/// @endcode +/// +/// Be aware that using a thread pool may break hard real-time rules due to the thread +/// synchronization involved. +/// +/// If the host knows that it is running under hard real-time pressure it may decide to not +/// provide this interface. + +static CLAP_CONSTEXPR const char CLAP_EXT_THREAD_POOL[] = "clap.thread-pool"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_thread_pool { + // Called by the thread pool + void(CLAP_ABI *exec)(const clap_plugin_t *plugin, uint32_t task_index); +} clap_plugin_thread_pool_t; + +typedef struct clap_host_thread_pool { + // Schedule num_tasks jobs in the host thread pool. + // It can't be called concurrently or from the thread pool. + // Will block until all the tasks are processed. + // This must be used exclusively for realtime processing within the process call. + // Returns true if the host did execute all the tasks, false if it rejected the request. + // The host should check that the plugin is within the process call, and if not, reject the exec + // request. + // [audio-thread] + bool(CLAP_ABI *request_exec)(const clap_host_t *host, uint32_t num_tasks); +} clap_host_thread_pool_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/timer-support.h b/tests/clap/ext/timer-support.h new file mode 100644 index 0000000..221de96 --- /dev/null +++ b/tests/clap/ext/timer-support.h @@ -0,0 +1,31 @@ +#pragma once + +#include "../plugin.h" + +static CLAP_CONSTEXPR const char CLAP_EXT_TIMER_SUPPORT[] = "clap.timer-support"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_timer_support { + // [main-thread] + void(CLAP_ABI *on_timer)(const clap_plugin_t *plugin, clap_id timer_id); +} clap_plugin_timer_support_t; + +typedef struct clap_host_timer_support { + // Registers a periodic timer. + // The host may adjust the period if it is under a certain threshold. + // 30 Hz should be allowed. + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *register_timer)(const clap_host_t *host, uint32_t period_ms, clap_id *timer_id); + + // Returns true on success. + // [main-thread] + bool(CLAP_ABI *unregister_timer)(const clap_host_t *host, clap_id timer_id); +} clap_host_timer_support_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/track-info.h b/tests/clap/ext/track-info.h new file mode 100644 index 0000000..3e1a555 --- /dev/null +++ b/tests/clap/ext/track-info.h @@ -0,0 +1,66 @@ +#pragma once + +#include "../plugin.h" +#include "../color.h" +#include "../string-sizes.h" + +// This extension let the plugin query info about the track it's in. +// It is useful when the plugin is created, to initialize some parameters (mix, dry, wet) +// and pick a suitable configuration regarding audio port type and channel count. + +static CLAP_CONSTEXPR const char CLAP_EXT_TRACK_INFO[] = "clap.track-info/1"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static CLAP_CONSTEXPR const char CLAP_EXT_TRACK_INFO_COMPAT[] = "clap.track-info.draft/1"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + CLAP_TRACK_INFO_HAS_TRACK_NAME = (1 << 0), + CLAP_TRACK_INFO_HAS_TRACK_COLOR = (1 << 1), + CLAP_TRACK_INFO_HAS_AUDIO_CHANNEL = (1 << 2), + + // This plugin is on a return track, initialize with wet 100% + CLAP_TRACK_INFO_IS_FOR_RETURN_TRACK = (1 << 3), + + // This plugin is on a bus track, initialize with appropriate settings for bus processing + CLAP_TRACK_INFO_IS_FOR_BUS = (1 << 4), + + // This plugin is on the master, initialize with appropriate settings for channel processing + CLAP_TRACK_INFO_IS_FOR_MASTER = (1 << 5), +}; + +typedef struct clap_track_info { + uint64_t flags; // see the flags above + + // track name, available if flags contain CLAP_TRACK_INFO_HAS_TRACK_NAME + char name[CLAP_NAME_SIZE]; + + // track color, available if flags contain CLAP_TRACK_INFO_HAS_TRACK_COLOR + clap_color_t color; + + // available if flags contain CLAP_TRACK_INFO_HAS_AUDIO_CHANNEL + // see audio-ports.h, struct clap_audio_port_info to learn how to use channel count and port type + int32_t audio_channel_count; + const char *audio_port_type; +} clap_track_info_t; + +typedef struct clap_plugin_track_info { + // Called when the info changes. + // [main-thread] + void(CLAP_ABI *changed)(const clap_plugin_t *plugin); +} clap_plugin_track_info_t; + +typedef struct clap_host_track_info { + // Get info about the track the plugin belongs to. + // Returns true on success and stores the result into info. + // [main-thread] + bool(CLAP_ABI *get)(const clap_host_t *host, clap_track_info_t *info); +} clap_host_track_info_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/ext/voice-info.h b/tests/clap/ext/voice-info.h new file mode 100644 index 0000000..038baec --- /dev/null +++ b/tests/clap/ext/voice-info.h @@ -0,0 +1,56 @@ +#pragma once + +#include "../plugin.h" + +// This extension indicates the number of voices the synthesizer has. +// It is useful for the host when performing polyphonic modulations, +// because the host needs its own voice management and should try to follow +// what the plugin is doing: +// - make the host's voice pool coherent with what the plugin has +// - turn the host's voice management to mono when the plugin is mono + +static CLAP_CONSTEXPR const char CLAP_EXT_VOICE_INFO[] = "clap.voice-info"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // Allows the host to send overlapping NOTE_ON events. + // The plugin will then rely upon the note_id to distinguish between them. + CLAP_VOICE_INFO_SUPPORTS_OVERLAPPING_NOTES = 1 << 0, +}; + +typedef struct clap_voice_info { + // voice_count is the current number of voices that the patch can use + // voice_capacity is the number of voices allocated voices + // voice_count should not be confused with the number of active voices. + // + // 1 <= voice_count <= voice_capacity + // + // For example, a synth can have a capacity of 8 voices, but be configured + // to only use 4 voices: {count: 4, capacity: 8}. + // + // If the voice_count is 1, then the synth is working in mono and the host + // can decide to only use global modulation mapping. + uint32_t voice_count; + uint32_t voice_capacity; + + uint64_t flags; +} clap_voice_info_t; + +typedef struct clap_plugin_voice_info { + // gets the voice info, returns true on success + // [main-thread && active] + bool(CLAP_ABI *get)(const clap_plugin_t *plugin, clap_voice_info_t *info); +} clap_plugin_voice_info_t; + +typedef struct clap_host_voice_info { + // informs the host that the voice info has changed + // [main-thread] + void(CLAP_ABI *changed)(const clap_host_t *host); +} clap_host_voice_info_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/factory/draft/plugin-invalidation.h b/tests/clap/factory/draft/plugin-invalidation.h new file mode 100644 index 0000000..7f65dd0 --- /dev/null +++ b/tests/clap/factory/draft/plugin-invalidation.h @@ -0,0 +1,47 @@ +#pragma once + +#include "../../private/std.h" +#include "../../private/macros.h" + +// Use it to retrieve const clap_plugin_invalidation_factory_t* from +// clap_plugin_entry.get_factory() +static const CLAP_CONSTEXPR char CLAP_PLUGIN_INVALIDATION_FACTORY_ID[] = + "clap.plugin-invalidation-factory/1"; + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_invalidation_source { + // Directory containing the file(s) to scan, must be absolute + const char *directory; + + // globing pattern, in the form *.dll + const char *filename_glob; + + // should the directory be scanned recursively? + bool recursive_scan; +} clap_plugin_invalidation_source_t; + +// Used to figure out when a plugin needs to be scanned again. +// Imagine a situation with a single entry point: my-plugin.clap which then scans itself +// a set of "sub-plugins". New plugin may be available even if my-plugin.clap file doesn't change. +// This interfaces solves this issue and gives a way to the host to monitor additional files. +typedef struct clap_plugin_invalidation_factory { + // Get the number of invalidation source. + uint32_t(CLAP_ABI *count)(const struct clap_plugin_invalidation_factory *factory); + + // Get the invalidation source by its index. + // [thread-safe] + const clap_plugin_invalidation_source_t *(CLAP_ABI *get)( + const struct clap_plugin_invalidation_factory *factory, uint32_t index); + + // In case the host detected a invalidation event, it can call refresh() to let the + // plugin_entry update the set of plugins available. + // If the function returned false, then the plugin needs to be reloaded. + bool(CLAP_ABI *refresh)(const struct clap_plugin_invalidation_factory *factory); +} clap_plugin_invalidation_factory_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/factory/draft/plugin-state-converter.h b/tests/clap/factory/draft/plugin-state-converter.h new file mode 100644 index 0000000..cfc9ad1 --- /dev/null +++ b/tests/clap/factory/draft/plugin-state-converter.h @@ -0,0 +1,99 @@ +#pragma once + +#include "../../id.h" +#include "../../universal-plugin-id.h" +#include "../../stream.h" +#include "../../version.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_state_converter_descriptor { + clap_version_t clap_version; + + clap_universal_plugin_id_t src_plugin_id; + clap_universal_plugin_id_t dst_plugin_id; + + const char *id; // eg: "com.u-he.diva-converter", mandatory + const char *name; // eg: "Diva Converter", mandatory + const char *vendor; // eg: "u-he" + const char *version; // eg: 1.1.5 + const char *description; // eg: "Official state converter for u-he Diva." +} clap_plugin_state_converter_descriptor_t; + +// This interface provides a mechanism for the host to convert a plugin state and its automation +// points to a new plugin. +// +// This is useful to convert from one plugin ABI to another one. +// This is also useful to offer an upgrade path: from EQ version 1 to EQ version 2. +// This can also be used to convert the state of a plugin that isn't maintained anymore into +// another plugin that would be similar. +typedef struct clap_plugin_state_converter { + const clap_plugin_state_converter_descriptor_t *desc; + + void *converter_data; + + // Destroy the converter. + void (*destroy)(struct clap_plugin_state_converter *converter); + + // Converts the input state to a state usable by the destination plugin. + // + // error_buffer is a place holder of error_buffer_size bytes for storing a null-terminated + // error message in case of failure, which can be displayed to the user. + // + // Returns true on success. + // [thread-safe] + bool (*convert_state)(struct clap_plugin_state_converter *converter, + const clap_istream_t *src, + const clap_ostream_t *dst, + char *error_buffer, + size_t error_buffer_size); + + // Converts a normalized value. + // Returns true on success. + // [thread-safe] + bool (*convert_normalized_value)(struct clap_plugin_state_converter *converter, + clap_id src_param_id, + double src_normalized_value, + clap_id *dst_param_id, + double *dst_normalized_value); + + // Converts a plain value. + // Returns true on success. + // [thread-safe] + bool (*convert_plain_value)(struct clap_plugin_state_converter *converter, + clap_id src_param_id, + double src_plain_value, + clap_id *dst_param_id, + double *dst_plain_value); +} clap_plugin_state_converter_t; + +// Factory identifier +static CLAP_CONSTEXPR const char CLAP_PLUGIN_STATE_CONVERTER_FACTORY_ID[] = + "clap.plugin-state-converter-factory/1"; + +// List all the plugin state converters available in the current DSO. +typedef struct clap_plugin_state_converter_factory { + // Get the number of converters. + // [thread-safe] + uint32_t (*count)(const struct clap_plugin_state_converter_factory *factory); + + // Retrieves a plugin state converter descriptor by its index. + // Returns null in case of error. + // The descriptor must not be freed. + // [thread-safe] + const clap_plugin_state_converter_descriptor_t *(*get_descriptor)( + const struct clap_plugin_state_converter_factory *factory, uint32_t index); + + // Create a plugin state converter by its converter_id. + // The returned pointer must be freed by calling converter->destroy(converter); + // Returns null in case of error. + // [thread-safe] + clap_plugin_state_converter_t *(*create)( + const struct clap_plugin_state_converter_factory *factory, const char *converter_id); +} clap_plugin_state_converter_factory_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/factory/plugin-factory.h b/tests/clap/factory/plugin-factory.h new file mode 100644 index 0000000..0899665 --- /dev/null +++ b/tests/clap/factory/plugin-factory.h @@ -0,0 +1,42 @@ +#pragma once + +#include "../plugin.h" + +// Use it to retrieve const clap_plugin_factory_t* from +// clap_plugin_entry.get_factory() +static const CLAP_CONSTEXPR char CLAP_PLUGIN_FACTORY_ID[] = "clap.plugin-factory"; + +#ifdef __cplusplus +extern "C" { +#endif + +// Every method must be thread-safe. +// It is very important to be able to scan the plugin as quickly as possible. +// +// The host may use clap_plugin_invalidation_factory to detect filesystem changes +// which may change the factory's content. +typedef struct clap_plugin_factory { + // Get the number of plugins available. + // [thread-safe] + uint32_t(CLAP_ABI *get_plugin_count)(const struct clap_plugin_factory *factory); + + // Retrieves a plugin descriptor by its index. + // Returns null in case of error. + // The descriptor must not be freed. + // [thread-safe] + const clap_plugin_descriptor_t *(CLAP_ABI *get_plugin_descriptor)( + const struct clap_plugin_factory *factory, uint32_t index); + + // Create a clap_plugin by its plugin_id. + // The returned pointer must be freed by calling plugin->destroy(plugin); + // The plugin is not allowed to use the host callbacks in the create method. + // Returns null in case of error. + // [thread-safe] + const clap_plugin_t *(CLAP_ABI *create_plugin)(const struct clap_plugin_factory *factory, + const clap_host_t *host, + const char *plugin_id); +} clap_plugin_factory_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/factory/preset-discovery.h b/tests/clap/factory/preset-discovery.h new file mode 100644 index 0000000..fbb0244 --- /dev/null +++ b/tests/clap/factory/preset-discovery.h @@ -0,0 +1,313 @@ +/* + Preset Discovery API. + + Preset Discovery enables a plug-in host to identify where presets are found, what + extensions they have, which plug-ins they apply to, and other metadata associated with the + presets so that they can be indexed and searched for quickly within the plug-in host's browser. + + This has a number of advantages for the user: + - it allows them to browse for presets from one central location in a consistent way + - the user can browse for presets without having to commit to a particular plug-in first + + The API works as follow to index presets and presets metadata: + 1. clap_plugin_entry.get_factory(CLAP_PRESET_DISCOVERY_FACTORY_ID) + 2. clap_preset_discovery_factory_t.create(...) + 3. clap_preset_discovery_provider.init() (only necessary the first time, declarations + can be cached) + `-> clap_preset_discovery_indexer.declare_filetype() + `-> clap_preset_discovery_indexer.declare_location() + `-> clap_preset_discovery_indexer.declare_soundpack() (optional) + `-> clap_preset_discovery_indexer.set_invalidation_watch_file() (optional) + 4. crawl the given locations and monitor file system changes + `-> clap_preset_discovery_indexer.get_metadata() for each presets files + + Then to load a preset, use ext/draft/preset-load.h. + TODO: create a dedicated repo for other plugin abi preset-load extension. + + The design of this API deliberately does not define a fixed set tags or categories. It is the + plug-in host's job to try to intelligently map the raw list of features that are found for a + preset and to process this list to generate something that makes sense for the host's tagging and + categorization system. The reason for this is to reduce the work for a plug-in developer to add + Preset Discovery support for their existing preset file format and not have to be concerned with + all the different hosts and how they want to receive the metadata. + + VERY IMPORTANT: + - the whole indexing process has to be **fast** + - clap_preset_provider->get_metadata() has to be fast and avoid unnecessary operations + - the whole indexing process must not be interactive + - don't show dialogs, windows, ... + - don't ask for user input +*/ + +#pragma once + +#include "../private/std.h" +#include "../private/macros.h" +#include "../timestamp.h" +#include "../version.h" +#include "../universal-plugin-id.h" + +// Use it to retrieve const clap_preset_discovery_factory_t* from +// clap_plugin_entry.get_factory() +static const CLAP_CONSTEXPR char CLAP_PRESET_DISCOVERY_FACTORY_ID[] = + "clap.preset-discovery-factory/2"; + +// The latest draft is 100% compatible. +// This compat ID may be removed in 2026. +static const CLAP_CONSTEXPR char CLAP_PRESET_DISCOVERY_FACTORY_ID_COMPAT[] = + "clap.preset-discovery-factory/draft-2"; + +#ifdef __cplusplus +extern "C" { +#endif + +enum clap_preset_discovery_location_kind { + // The preset are located in a file on the OS filesystem. + // The location is then a path which works with the OS file system functions (open, stat, ...) + // So both '/' and '\' shall work on Windows as a separator. + CLAP_PRESET_DISCOVERY_LOCATION_FILE = 0, + + // The preset is bundled within the plugin DSO itself. + // The location must then be null, as the preset are within the plugin itself and then the plugin + // will act as a preset container. + CLAP_PRESET_DISCOVERY_LOCATION_PLUGIN = 1, +}; + +enum clap_preset_discovery_flags { + // This is for factory or sound-pack presets. + CLAP_PRESET_DISCOVERY_IS_FACTORY_CONTENT = 1 << 0, + + // This is for user presets. + CLAP_PRESET_DISCOVERY_IS_USER_CONTENT = 1 << 1, + + // This location is meant for demo presets, those are preset which may trigger + // some limitation in the plugin because they require additional features which the user + // needs to purchase or the content itself needs to be bought and is only available in + // demo mode. + CLAP_PRESET_DISCOVERY_IS_DEMO_CONTENT = 1 << 2, + + // This preset is a user's favorite + CLAP_PRESET_DISCOVERY_IS_FAVORITE = 1 << 3, +}; + +// Receiver that receives the metadata for a single preset file. +// The host would define the various callbacks in this interface and the preset parser function +// would then call them. +// +// This interface isn't thread-safe. +typedef struct clap_preset_discovery_metadata_receiver { + void *receiver_data; // reserved pointer for the metadata receiver + + // If there is an error reading metadata from a file this should be called with an error + // message. + // os_error: the operating system error, if applicable. If not applicable set it to a non-error + // value, eg: 0 on unix and Windows. + void(CLAP_ABI *on_error)(const struct clap_preset_discovery_metadata_receiver *receiver, + int32_t os_error, + const char *error_message); + + // This must be called for every preset in the file and before any preset metadata is + // sent with the calls below. + // + // If the preset file is a preset container then name and load_key are mandatory, otherwise + // they are optional. + // + // The load_key is a machine friendly string used to load the preset inside the container via a + // the preset-load plug-in extension. The load_key can also just be the subpath if that's what + // the plugin wants but it could also be some other unique id like a database primary key or a + // binary offset. It's use is entirely up to the plug-in. + // + // If the function returns false, then the provider must stop calling back into the receiver. + bool(CLAP_ABI *begin_preset)(const struct clap_preset_discovery_metadata_receiver *receiver, + const char *name, + const char *load_key); + + // Adds a plug-in id that this preset can be used with. + void(CLAP_ABI *add_plugin_id)(const struct clap_preset_discovery_metadata_receiver *receiver, + const clap_universal_plugin_id_t *plugin_id); + + // Sets the sound pack to which the preset belongs to. + void(CLAP_ABI *set_soundpack_id)(const struct clap_preset_discovery_metadata_receiver *receiver, + const char *soundpack_id); + + // Sets the flags, see clap_preset_discovery_flags. + // If unset, they are then inherited from the location. + void(CLAP_ABI *set_flags)(const struct clap_preset_discovery_metadata_receiver *receiver, + uint32_t flags); + + // Adds a creator name for the preset. + void(CLAP_ABI *add_creator)(const struct clap_preset_discovery_metadata_receiver *receiver, + const char *creator); + + // Sets a description of the preset. + void(CLAP_ABI *set_description)(const struct clap_preset_discovery_metadata_receiver *receiver, + const char *description); + + // Sets the creation time and last modification time of the preset. + // If one of the times isn't known, set it to CLAP_TIMESTAMP_UNKNOWN. + // If this function is not called, then the indexer may look at the file's creation and + // modification time. + void(CLAP_ABI *set_timestamps)(const struct clap_preset_discovery_metadata_receiver *receiver, + clap_timestamp creation_time, + clap_timestamp modification_time); + + // Adds a feature to the preset. + // + // The feature string is arbitrary, it is the indexer's job to understand it and remap it to its + // internal categorization and tagging system. + // + // However, the strings from plugin-features.h should be understood by the indexer and one of the + // plugin category could be provided to determine if the preset will result into an audio-effect, + // instrument, ... + // + // Examples: + // kick, drum, tom, snare, clap, cymbal, bass, lead, metalic, hardsync, crossmod, acid, + // distorted, drone, pad, dirty, etc... + void(CLAP_ABI *add_feature)(const struct clap_preset_discovery_metadata_receiver *receiver, + const char *feature); + + // Adds extra information to the metadata. + void(CLAP_ABI *add_extra_info)(const struct clap_preset_discovery_metadata_receiver *receiver, + const char *key, + const char *value); +} clap_preset_discovery_metadata_receiver_t; + +typedef struct clap_preset_discovery_filetype { + const char *name; + const char *description; // optional + + // `.' isn't included in the string. + // If empty or NULL then every file should be matched. + const char *file_extension; +} clap_preset_discovery_filetype_t; + +// Defines a place in which to search for presets +typedef struct clap_preset_discovery_location { + uint32_t flags; // see enum clap_preset_discovery_flags + const char *name; // name of this location + uint32_t kind; // See clap_preset_discovery_location_kind + + // Actual location in which to crawl presets. + // For FILE kind, the location can be either a path to a directory or a file. + // For PLUGIN kind, the location must be null. + const char *location; +} clap_preset_discovery_location_t; + +// Describes an installed sound pack. +typedef struct clap_preset_discovery_soundpack { + uint32_t flags; // see enum clap_preset_discovery_flags + const char *id; // sound pack identifier + const char *name; // name of this sound pack + const char *description; // optional, reasonably short description of the sound pack + const char *homepage_url; // optional, url to the pack's homepage + const char *vendor; // optional, sound pack's vendor + const char *image_path; // optional, an image on disk + clap_timestamp release_timestamp; // release date, CLAP_TIMESTAMP_UNKNOWN if unavailable +} clap_preset_discovery_soundpack_t; + +// Describes a preset provider +typedef struct clap_preset_discovery_provider_descriptor { + clap_version_t clap_version; // initialized to CLAP_VERSION + const char *id; // see plugin.h for advice on how to choose a good identifier + const char *name; // eg: "Diva's preset provider" + const char *vendor; // optional, eg: u-he +} clap_preset_discovery_provider_descriptor_t; + +// This interface isn't thread-safe. +typedef struct clap_preset_discovery_provider { + const clap_preset_discovery_provider_descriptor_t *desc; + + void *provider_data; // reserved pointer for the provider + + // Initialize the preset provider. + // It should declare all its locations, filetypes and sound packs. + // Returns false if initialization failed. + bool(CLAP_ABI *init)(const struct clap_preset_discovery_provider *provider); + + // Destroys the preset provider + void(CLAP_ABI *destroy)(const struct clap_preset_discovery_provider *provider); + + // reads metadata from the given file and passes them to the metadata receiver + // Returns true on success. + bool(CLAP_ABI *get_metadata)(const struct clap_preset_discovery_provider *provider, + uint32_t location_kind, + const char *location, + const clap_preset_discovery_metadata_receiver_t *metadata_receiver); + + // Query an extension. + // The returned pointer is owned by the provider. + // It is forbidden to call it before provider->init(). + // You can call it within provider->init() call, and after. + const void *(CLAP_ABI *get_extension)(const struct clap_preset_discovery_provider *provider, + const char *extension_id); +} clap_preset_discovery_provider_t; + +// This interface isn't thread-safe +typedef struct clap_preset_discovery_indexer { + clap_version_t clap_version; // initialized to CLAP_VERSION + const char *name; // eg: "Bitwig Studio" + const char *vendor; // optional, eg: "Bitwig GmbH" + const char *url; // optional, eg: "https://bitwig.com" + const char *version; // optional, eg: "4.3", see plugin.h for advice on how to format the version + + void *indexer_data; // reserved pointer for the indexer + + // Declares a preset filetype. + // Don't callback into the provider during this call. + // Returns false if the filetype is invalid. + bool(CLAP_ABI *declare_filetype)(const struct clap_preset_discovery_indexer *indexer, + const clap_preset_discovery_filetype_t *filetype); + + // Declares a preset location. + // Don't callback into the provider during this call. + // Returns false if the location is invalid. + bool(CLAP_ABI *declare_location)(const struct clap_preset_discovery_indexer *indexer, + const clap_preset_discovery_location_t *location); + + // Declares a sound pack. + // Don't callback into the provider during this call. + // Returns false if the sound pack is invalid. + bool(CLAP_ABI *declare_soundpack)(const struct clap_preset_discovery_indexer *indexer, + const clap_preset_discovery_soundpack_t *soundpack); + + // Query an extension. + // The returned pointer is owned by the indexer. + // It is forbidden to call it before provider->init(). + // You can call it within provider->init() call, and after. + const void *(CLAP_ABI *get_extension)(const struct clap_preset_discovery_indexer *indexer, + const char *extension_id); +} clap_preset_discovery_indexer_t; + +// Every methods in this factory must be thread-safe. +// It is encouraged to perform preset indexing in background threads, maybe even in background +// process. +// +// The host may use clap_plugin_invalidation_factory to detect filesystem changes +// which may change the factory's content. +typedef struct clap_preset_discovery_factory { + // Get the number of preset providers available. + // [thread-safe] + uint32_t(CLAP_ABI *count)(const struct clap_preset_discovery_factory *factory); + + // Retrieves a preset provider descriptor by its index. + // Returns null in case of error. + // The descriptor must not be freed. + // [thread-safe] + const clap_preset_discovery_provider_descriptor_t *(CLAP_ABI *get_descriptor)( + const struct clap_preset_discovery_factory *factory, uint32_t index); + + // Create a preset provider by its id. + // The returned pointer must be freed by calling preset_provider->destroy(preset_provider); + // The preset provider is not allowed to use the indexer callbacks in the create method. + // It is forbidden to call back into the indexer before the indexer calls provider->init(). + // Returns null in case of error. + // [thread-safe] + const clap_preset_discovery_provider_t *(CLAP_ABI *create)( + const struct clap_preset_discovery_factory *factory, + const clap_preset_discovery_indexer_t *indexer, + const char *provider_id); +} clap_preset_discovery_factory_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/fixedpoint.h b/tests/clap/fixedpoint.h new file mode 100644 index 0000000..fb042d3 --- /dev/null +++ b/tests/clap/fixedpoint.h @@ -0,0 +1,16 @@ +#pragma once + +#include "private/std.h" +#include "private/macros.h" + +/// We use fixed point representation of beat time and seconds time +/// Usage: +/// double x = ...; // in beats +/// clap_beattime y = round(CLAP_BEATTIME_FACTOR * x); + +// This will never change +static const CLAP_CONSTEXPR int64_t CLAP_BEATTIME_FACTOR = 1LL << 31; +static const CLAP_CONSTEXPR int64_t CLAP_SECTIME_FACTOR = 1LL << 31; + +typedef int64_t clap_beattime; +typedef int64_t clap_sectime; diff --git a/tests/clap/host.h b/tests/clap/host.h new file mode 100644 index 0000000..c154c82 --- /dev/null +++ b/tests/clap/host.h @@ -0,0 +1,51 @@ +#pragma once + +#include "version.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_host { + clap_version_t clap_version; // initialized to CLAP_VERSION + + void *host_data; // reserved pointer for the host + + // name and version are mandatory. + const char *name; // eg: "Bitwig Studio" + const char *vendor; // eg: "Bitwig GmbH" + const char *url; // eg: "https://bitwig.com" + const char *version; // eg: "4.3", see plugin.h for advice on how to format the version + + // Query an extension. + // The returned pointer is owned by the host. + // It is forbidden to call it before plugin->init(). + // You can call it within plugin->init() call, and after. + // [thread-safe] + const void *(CLAP_ABI *get_extension)(const struct clap_host *host, const char *extension_id); + + // Request the host to deactivate and then reactivate the plugin. + // The operation may be delayed by the host. + // [thread-safe] + void(CLAP_ABI *request_restart)(const struct clap_host *host); + + // Request the host to activate and start processing the plugin. + // This is useful if you have external IO and need to wake up the plugin from "sleep". + // [thread-safe] + void(CLAP_ABI *request_process)(const struct clap_host *host); + + // Request the host to schedule a call to plugin->on_main_thread(plugin) on the main thread. + // This callback should be called as soon as practicable, usually in the host application's next + // available main thread time slice. Typically callbacks occur within 33ms / 30hz. + // Despite this guidance, plugins should not make assumptions about the exactness of timing for + // a main thread callback, but hosts should endeavour to be prompt. For example, in high load + // situations the environment may starve the gui/main thread in favor of audio processing, + // leading to substantially longer latencies for the callback than the indicative times given + // here. + // [thread-safe] + void(CLAP_ABI *request_callback)(const struct clap_host *host); +} clap_host_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/id.h b/tests/clap/id.h new file mode 100644 index 0000000..3b2b6e6 --- /dev/null +++ b/tests/clap/id.h @@ -0,0 +1,8 @@ +#pragma once + +#include "private/std.h" +#include "private/macros.h" + +typedef uint32_t clap_id; + +static const CLAP_CONSTEXPR clap_id CLAP_INVALID_ID = UINT32_MAX; diff --git a/tests/clap/plugin-features.h b/tests/clap/plugin-features.h new file mode 100644 index 0000000..e5dc18c --- /dev/null +++ b/tests/clap/plugin-features.h @@ -0,0 +1,79 @@ +#pragma once + +// This file provides a set of standard plugin features meant to be used +// within clap_plugin_descriptor.features. +// +// For practical reasons we'll avoid spaces and use `-` instead to facilitate +// scripts that generate the feature array. +// +// Non-standard features should be formatted as follow: "$namespace:$feature" + +///////////////////// +// Plugin category // +///////////////////// + +// Add this feature if your plugin can process note events and then produce audio +#define CLAP_PLUGIN_FEATURE_INSTRUMENT "instrument" + +// Add this feature if your plugin is an audio effect +#define CLAP_PLUGIN_FEATURE_AUDIO_EFFECT "audio-effect" + +// Add this feature if your plugin is a note effect or a note generator/sequencer +#define CLAP_PLUGIN_FEATURE_NOTE_EFFECT "note-effect" + +// Add this feature if your plugin converts audio to notes +#define CLAP_PLUGIN_FEATURE_NOTE_DETECTOR "note-detector" + +// Add this feature if your plugin is an analyzer +#define CLAP_PLUGIN_FEATURE_ANALYZER "analyzer" + +///////////////////////// +// Plugin sub-category // +///////////////////////// + +#define CLAP_PLUGIN_FEATURE_SYNTHESIZER "synthesizer" +#define CLAP_PLUGIN_FEATURE_SAMPLER "sampler" +#define CLAP_PLUGIN_FEATURE_DRUM "drum" // For single drum +#define CLAP_PLUGIN_FEATURE_DRUM_MACHINE "drum-machine" + +#define CLAP_PLUGIN_FEATURE_FILTER "filter" +#define CLAP_PLUGIN_FEATURE_PHASER "phaser" +#define CLAP_PLUGIN_FEATURE_EQUALIZER "equalizer" +#define CLAP_PLUGIN_FEATURE_DEESSER "de-esser" +#define CLAP_PLUGIN_FEATURE_PHASE_VOCODER "phase-vocoder" +#define CLAP_PLUGIN_FEATURE_GRANULAR "granular" +#define CLAP_PLUGIN_FEATURE_FREQUENCY_SHIFTER "frequency-shifter" +#define CLAP_PLUGIN_FEATURE_PITCH_SHIFTER "pitch-shifter" + +#define CLAP_PLUGIN_FEATURE_DISTORTION "distortion" +#define CLAP_PLUGIN_FEATURE_TRANSIENT_SHAPER "transient-shaper" +#define CLAP_PLUGIN_FEATURE_COMPRESSOR "compressor" +#define CLAP_PLUGIN_FEATURE_EXPANDER "expander" +#define CLAP_PLUGIN_FEATURE_GATE "gate" +#define CLAP_PLUGIN_FEATURE_LIMITER "limiter" + +#define CLAP_PLUGIN_FEATURE_FLANGER "flanger" +#define CLAP_PLUGIN_FEATURE_CHORUS "chorus" +#define CLAP_PLUGIN_FEATURE_DELAY "delay" +#define CLAP_PLUGIN_FEATURE_REVERB "reverb" + +#define CLAP_PLUGIN_FEATURE_TREMOLO "tremolo" +#define CLAP_PLUGIN_FEATURE_GLITCH "glitch" + +#define CLAP_PLUGIN_FEATURE_UTILITY "utility" +#define CLAP_PLUGIN_FEATURE_PITCH_CORRECTION "pitch-correction" +#define CLAP_PLUGIN_FEATURE_RESTORATION "restoration" // repair the sound + +#define CLAP_PLUGIN_FEATURE_MULTI_EFFECTS "multi-effects" + +#define CLAP_PLUGIN_FEATURE_MIXING "mixing" +#define CLAP_PLUGIN_FEATURE_MASTERING "mastering" + +//////////////////////// +// Audio Capabilities // +//////////////////////// + +#define CLAP_PLUGIN_FEATURE_MONO "mono" +#define CLAP_PLUGIN_FEATURE_STEREO "stereo" +#define CLAP_PLUGIN_FEATURE_SURROUND "surround" +#define CLAP_PLUGIN_FEATURE_AMBISONIC "ambisonic" diff --git a/tests/clap/plugin.h b/tests/clap/plugin.h new file mode 100644 index 0000000..0a23945 --- /dev/null +++ b/tests/clap/plugin.h @@ -0,0 +1,114 @@ +#pragma once + +#include "private/macros.h" +#include "host.h" +#include "process.h" +#include "plugin-features.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_plugin_descriptor { + clap_version_t clap_version; // initialized to CLAP_VERSION + + // Mandatory fields must be set and must not be blank. + // Otherwise the fields can be null or blank, though it is safer to make them blank. + // + // Some indications regarding id and version + // - id is an arbitrary string which should be unique to your plugin, + // we encourage you to use a reverse URI eg: "com.u-he.diva" + // - version is an arbitrary string which describes a plugin, + // it is useful for the host to understand and be able to compare two different + // version strings, so here is a regex like expression which is likely to be + // understood by most hosts: MAJOR(.MINOR(.REVISION)?)?( (Alpha|Beta) XREV)? + const char *id; // eg: "com.u-he.diva", mandatory + const char *name; // eg: "Diva", mandatory + const char *vendor; // eg: "u-he" + const char *url; // eg: "https://u-he.com/products/diva/" + const char *manual_url; // eg: "https://dl.u-he.com/manuals/plugins/diva/Diva-user-guide.pdf" + const char *support_url; // eg: "https://u-he.com/support/" + const char *version; // eg: "1.4.4" + const char *description; // eg: "The spirit of analogue" + + // Arbitrary list of keywords. + // They can be matched by the host indexer and used to classify the plugin. + // The array of pointers must be null terminated. + // For some standard features see plugin-features.h + const char *const *features; +} clap_plugin_descriptor_t; + +typedef struct clap_plugin { + const clap_plugin_descriptor_t *desc; + + void *plugin_data; // reserved pointer for the plugin + + // Must be called after creating the plugin. + // If init returns false, the host must destroy the plugin instance. + // If init returns true, then the plugin is initialized and in the deactivated state. + // Unlike in `plugin-factory::create_plugin`, in init you have complete access to the host + // and host extensions, so clap related setup activities should be done here rather than in + // create_plugin. + // [main-thread] + bool(CLAP_ABI *init)(const struct clap_plugin *plugin); + + // Free the plugin and its resources. + // It is required to deactivate the plugin prior to this call. + // [main-thread & !active] + void(CLAP_ABI *destroy)(const struct clap_plugin *plugin); + + // Activate and deactivate the plugin. + // In this call the plugin may allocate memory and prepare everything needed for the process + // call. The process's sample rate will be constant and process's frame count will included in + // the [min, max] range, which is bounded by [1, INT32_MAX]. + // In this call the plugin may call host-provided methods marked [being-activated]. + // Once activated the latency and port configuration must remain constant, until deactivation. + // Returns true on success. + // [main-thread & !active] + bool(CLAP_ABI *activate)(const struct clap_plugin *plugin, + double sample_rate, + uint32_t min_frames_count, + uint32_t max_frames_count); + // [main-thread & active] + void(CLAP_ABI *deactivate)(const struct clap_plugin *plugin); + + // Call start processing before processing. + // Returns true on success. + // [audio-thread & active & !processing] + bool(CLAP_ABI *start_processing)(const struct clap_plugin *plugin); + + // Call stop processing before sending the plugin to sleep. + // [audio-thread & active & processing] + void(CLAP_ABI *stop_processing)(const struct clap_plugin *plugin); + + // - Clears all buffers, performs a full reset of the processing state (filters, oscillators, + // envelopes, lfo, ...) and kills all voices. + // - The parameter's value remain unchanged. + // - clap_process.steady_time may jump backward. + // + // [audio-thread & active] + void(CLAP_ABI *reset)(const struct clap_plugin *plugin); + + // process audio, events, ... + // All the pointers coming from clap_process_t and its nested attributes, + // are valid until process() returns. + // [audio-thread & active & processing] + clap_process_status(CLAP_ABI *process)(const struct clap_plugin *plugin, + const clap_process_t *process); + + // Query an extension. + // The returned pointer is owned by the plugin. + // It is forbidden to call it before plugin->init(). + // You can call it within plugin->init() call, and after. + // [thread-safe] + const void *(CLAP_ABI *get_extension)(const struct clap_plugin *plugin, const char *id); + + // Called by the host on the main thread in response to a previous call to: + // host->request_callback(host); + // [main-thread] + void(CLAP_ABI *on_main_thread)(const struct clap_plugin *plugin); +} clap_plugin_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/private/macros.h b/tests/clap/private/macros.h new file mode 100644 index 0000000..ba1d665 --- /dev/null +++ b/tests/clap/private/macros.h @@ -0,0 +1,50 @@ +#pragma once + +// Define CLAP_EXPORT +#if !defined(CLAP_EXPORT) +# if defined _WIN32 || defined __CYGWIN__ +# ifdef __GNUC__ +# define CLAP_EXPORT __attribute__((dllexport)) +# else +# define CLAP_EXPORT __declspec(dllexport) +# endif +# else +# if __GNUC__ >= 4 || defined(__clang__) +# define CLAP_EXPORT __attribute__((visibility("default"))) +# else +# define CLAP_EXPORT +# endif +# endif +#endif + +#if !defined(CLAP_ABI) +# if defined _WIN32 || defined __CYGWIN__ +# define CLAP_ABI __cdecl +# else +# define CLAP_ABI +# endif +#endif + +#if defined(_MSVC_LANG) +# define CLAP_CPLUSPLUS _MSVC_LANG +#elif defined(__cplusplus) +# define CLAP_CPLUSPLUS __cplusplus +#endif + +#if defined(CLAP_CPLUSPLUS) && CLAP_CPLUSPLUS >= 201103L +# define CLAP_HAS_CXX11 +# define CLAP_CONSTEXPR constexpr +#else +# define CLAP_CONSTEXPR +#endif + +#if defined(CLAP_CPLUSPLUS) && CLAP_CPLUSPLUS >= 201703L +# define CLAP_HAS_CXX17 +# define CLAP_NODISCARD [[nodiscard]] +#else +# define CLAP_NODISCARD +#endif + +#if defined(CLAP_CPLUSPLUS) && CLAP_CPLUSPLUS >= 202002L +# define CLAP_HAS_CXX20 +#endif diff --git a/tests/clap/private/std.h b/tests/clap/private/std.h new file mode 100644 index 0000000..1c2ffdd --- /dev/null +++ b/tests/clap/private/std.h @@ -0,0 +1,16 @@ +#pragma once + +#include "macros.h" + +#ifdef CLAP_HAS_CXX11 +# include +#else +# include +#endif + +#ifdef __cplusplus +# include +#else +# include +# include +#endif diff --git a/tests/clap/process.h b/tests/clap/process.h new file mode 100644 index 0000000..c9dbf92 --- /dev/null +++ b/tests/clap/process.h @@ -0,0 +1,66 @@ +#pragma once + +#include "events.h" +#include "audio-buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // Processing failed. The output buffer must be discarded. + CLAP_PROCESS_ERROR = 0, + + // Processing succeeded, keep processing. + CLAP_PROCESS_CONTINUE = 1, + + // Processing succeeded, keep processing if the output is not quiet. + CLAP_PROCESS_CONTINUE_IF_NOT_QUIET = 2, + + // Rely upon the plugin's tail to determine if the plugin should continue to process. + // see clap_plugin_tail + CLAP_PROCESS_TAIL = 3, + + // Processing succeeded, but no more processing is required, + // until the next event or variation in audio input. + CLAP_PROCESS_SLEEP = 4, +}; +typedef int32_t clap_process_status; + +typedef struct clap_process { + // A steady sample time counter. + // This field can be used to calculate the sleep duration between two process calls. + // This value may be specific to this plugin instance and have no relation to what + // other plugin instances may receive. + // + // Set to -1 if not available, otherwise the value must be greater or equal to 0, + // and must be increased by at least `frames_count` for the next call to process. + int64_t steady_time; + + // Number of frames to process + uint32_t frames_count; + + // time info at sample 0 + // If null, then this is a free running host, no transport events will be provided + const clap_event_transport_t *transport; + + // Audio buffers, they must have the same count as specified + // by clap_plugin_audio_ports->count(). + // The index maps to clap_plugin_audio_ports->get(). + // Input buffer and its contents are read-only. + const clap_audio_buffer_t *audio_inputs; + clap_audio_buffer_t *audio_outputs; + uint32_t audio_inputs_count; + uint32_t audio_outputs_count; + + // The input event list can't be modified. + // Input read-only event list. The host will deliver these sorted in sample order. + const clap_input_events_t *in_events; + + // Output event list. The plugin must insert events in sample sorted order when inserting events + const clap_output_events_t *out_events; +} clap_process_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/stream.h b/tests/clap/stream.h new file mode 100644 index 0000000..b9b0b6c --- /dev/null +++ b/tests/clap/stream.h @@ -0,0 +1,38 @@ +#pragma once + +#include "private/std.h" +#include "private/macros.h" + +/// @page Streams +/// +/// ## Notes on using streams +/// +/// When working with `clap_istream` and `clap_ostream` objects to load and save +/// state, it is important to keep in mind that the host may limit the number of +/// bytes that can be read or written at a time. The return values for the +/// stream read and write functions indicate how many bytes were actually read +/// or written. You need to use a loop to ensure that you read or write the +/// entirety of your state. Don't forget to also consider the negative return +/// values for the end of file and IO error codes. + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_istream { + void *ctx; // reserved pointer for the stream + + // returns the number of bytes read; 0 indicates end of file and -1 a read error + int64_t(CLAP_ABI *read)(const struct clap_istream *stream, void *buffer, uint64_t size); +} clap_istream_t; + +typedef struct clap_ostream { + void *ctx; // reserved pointer for the stream + + // returns the number of bytes written; -1 on write error + int64_t(CLAP_ABI *write)(const struct clap_ostream *stream, const void *buffer, uint64_t size); +} clap_ostream_t; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/string-sizes.h b/tests/clap/string-sizes.h new file mode 100644 index 0000000..4334c6d --- /dev/null +++ b/tests/clap/string-sizes.h @@ -0,0 +1,21 @@ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + // String capacity for names that can be displayed to the user. + CLAP_NAME_SIZE = 256, + + // String capacity for describing a path, like a parameter in a module hierarchy or path within a + // set of nested track groups. + // + // This is not suited for describing a file path on the disk, as NTFS allows up to 32K long + // paths. + CLAP_PATH_SIZE = 1024, +}; + +#ifdef __cplusplus +} +#endif diff --git a/tests/clap/timestamp.h b/tests/clap/timestamp.h new file mode 100644 index 0000000..63d2cab --- /dev/null +++ b/tests/clap/timestamp.h @@ -0,0 +1,11 @@ +#pragma once + +#include "private/std.h" +#include "private/macros.h" + +// This type defines a timestamp: the number of seconds since UNIX EPOCH. +// See C's time_t time(time_t *). +typedef uint64_t clap_timestamp; + +// Value for unknown timestamp. +static const CLAP_CONSTEXPR clap_timestamp CLAP_TIMESTAMP_UNKNOWN = 0; diff --git a/tests/clap/universal-plugin-id.h b/tests/clap/universal-plugin-id.h new file mode 100644 index 0000000..b039d03 --- /dev/null +++ b/tests/clap/universal-plugin-id.h @@ -0,0 +1,26 @@ +#pragma once + +// Pair of plugin ABI and plugin identifier. +// +// If you want to represent other formats please send us an update to the comment with the +// name of the abi and the representation of the id. +typedef struct clap_universal_plugin_id { + // The plugin ABI name, in lowercase and null-terminated. + // eg: "clap", "vst3", "vst2", "au", ... + const char *abi; + + // The plugin ID, null-terminated and formatted as follows: + // + // CLAP: use the plugin id + // eg: "com.u-he.diva" + // + // AU: format the string like "type:subt:manu" + // eg: "aumu:SgXT:VmbA" + // + // VST2: print the id as a signed 32-bits integer + // eg: "-4382976" + // + // VST3: print the id as a standard UUID + // eg: "123e4567-e89b-12d3-a456-426614174000" + const char *id; +} clap_universal_plugin_id_t; diff --git a/tests/clap/version.h b/tests/clap/version.h new file mode 100644 index 0000000..0d64451 --- /dev/null +++ b/tests/clap/version.h @@ -0,0 +1,42 @@ +#pragma once + +#include "private/macros.h" +#include "private/std.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct clap_version { + // This is the major ABI and API design + // Version 0.X.Y correspond to the development stage, API and ABI are not stable + // Version 1.X.Y correspond to the release stage, API and ABI are stable + uint32_t major; + uint32_t minor; + uint32_t revision; +} clap_version_t; + +#ifdef __cplusplus +} +#endif + +#define CLAP_VERSION_MAJOR 1 +#define CLAP_VERSION_MINOR 2 +#define CLAP_VERSION_REVISION 6 + +#define CLAP_VERSION_INIT \ + { (uint32_t)CLAP_VERSION_MAJOR, (uint32_t)CLAP_VERSION_MINOR, (uint32_t)CLAP_VERSION_REVISION } + +#define CLAP_VERSION_LT(maj,min,rev) ((CLAP_VERSION_MAJOR < (maj)) || \ + ((maj) == CLAP_VERSION_MAJOR && CLAP_VERSION_MINOR < (min)) || \ + ((maj) == CLAP_VERSION_MAJOR && (min) == CLAP_VERSION_MINOR && CLAP_VERSION_REVISION < (rev))) +#define CLAP_VERSION_EQ(maj,min,rev) (((maj) == CLAP_VERSION_MAJOR) && ((min) == CLAP_VERSION_MINOR) && ((rev) == CLAP_VERSION_REVISION)) +#define CLAP_VERSION_GE(maj,min,rev) (!CLAP_VERSION_LT(maj,min,rev)) + +static const CLAP_CONSTEXPR clap_version_t CLAP_VERSION = CLAP_VERSION_INIT; + +CLAP_NODISCARD static inline CLAP_CONSTEXPR bool +clap_version_is_compatible(const clap_version_t v) { + // versions 0.x.y were used during development stage and aren't compatible + return v.major >= 1; +} diff --git a/tests/plugin.cpp b/tests/plugin.cpp new file mode 100644 index 0000000..11353c1 --- /dev/null +++ b/tests/plugin.cpp @@ -0,0 +1,437 @@ +#include "clap/clap.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static std::string *font_path; + +struct Note { + int32_t key; + int32_t note_id; + int32_t channel; + float phase; +}; + +class PluginGUI { +public: + PluginGUI() { + strcpy(counter_buffer, "0"); + counter = 0; + + font = pgpl_font_create_from_file(font_path->c_str(), 256); + + pgpl_gui_theme_configure(&theme, pgpl_color_create(255, 255, 255, 255), 48, + font); + + gui = pgpl_gui_create("PGPL Test", 320, 320, 0, 0, &theme, this); + + pgpl_gui_widget_add(gui, create_main_view()); + + pgpl_gui_run_and_show(gui, false); + } + + ~PluginGUI() { pgpl_font_destroy(NULL, font); } + + inline PGPL_WindowThread *get_window() { return gui->window_thread; } + +private: + static void on_counter_button_click(void *data) { + PluginGUI *app = (PluginGUI *)data; + app->counter++; + snprintf(app->counter_buffer, sizeof(app->counter_buffer), "%d", + app->counter); + + if (app->counter % 10 == 0) { + pgpl_gui_theme_configure( + &app->gui->theme, + pgpl_color_create(rand() % 256, rand() % 256, rand() % 256, 255), 48, + app->gui->theme.font); + } + } + + static void configure_widget_default(PGPL_GuiWidget *widget) { + pgpl_gui_widget_configure(widget, 0, 0, true, true, true, true, + PGPL_GUI_FONT_SIZE_CONTENT, NULL, false, false, + false, false); + } + + PGPL_GuiWidget *create_main_view() { + PGPL_GuiButtonWidget *counter_button; + PGPL_GuiTextWidget *counter; + + column_layout = pgpl_gui_container_layout_create( + PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL); + pgpl_gui_widget_configure(&column_layout->parent, 0, 0, true, true, false, + false, PGPL_GUI_FONT_SIZE_CONTENT, NULL, false, + true, true, false); + + counter_button = + pgpl_gui_button_widget_create("Click me!", on_counter_button_click); + configure_widget_default(&counter_button->parent); + + counter = pgpl_gui_text_widget_create(counter_buffer); + configure_widget_default(&counter->parent); + counter->parent.font_size = PGPL_GUI_FONT_SIZE_TITLE; + counter->parent.background = false; + counter->parent.border = false; + + pgpl_gui_container_layout_widget_add(column_layout, &counter->parent); + pgpl_gui_container_layout_widget_add(column_layout, + &counter_button->parent); + + return (PGPL_GuiWidget *)column_layout; + } + + PGPL_GuiContainerLayout *column_layout; + PGPL_Gui *gui; + PGPL_GuiTheme theme; + PGPL_Font *font; + int counter; + char counter_buffer[128]; +}; + +class PluginState { +public: + void process_event(const clap_event_header_t *event) { + if (event->space_id == CLAP_CORE_EVENT_SPACE_ID) { + if (event->type == CLAP_EVENT_NOTE_OFF || + event->type == CLAP_EVENT_NOTE_CHOKE) { + const clap_event_note_t *note_event = (const clap_event_note_t *)event; + + for (size_t i = 0; i < this->notes.size(); i++) { + Note ¬e = this->notes[i]; + + if (note_event->note_id == note.note_id || + note_event->note_id == -1) { + this->notes.erase(this->notes.begin() + i--); + } + } + + } else if (event->type == CLAP_EVENT_NOTE_ON) { + const clap_event_note_t *note_event = (const clap_event_note_t *)event; + this->notes.push_back( + {note_event->key, note_event->note_id, note_event->channel, 0.0f}); + } + } + } + + void render_audio(float *outputL, float *outputR, uint32_t length) { + for (uint32_t index = 0; index < length; index++) { + float sum = 0.0f; + + for (size_t i = 0; i < this->notes.size(); i++) { + Note ¬e = this->notes[i]; + sum += sinf(2.0f * 3.14159f * 440.0f * + exp2f((note.key - 81.0f) / 12.0f) * note.phase) * + 0.2f; + note.phase += 1.0f / sample_rate; + note.phase -= floorf(note.phase); + } + + outputL[index] = sum; + outputR[index] = sum; + } + } + + inline void set_sample_rate(uint32_t sample_rate) { + this->sample_rate = sample_rate; + } + + inline void create_window() { gui = new PluginGUI(); } + + inline void destroy_window() { delete gui; } + + inline PGPL_WindowThread *get_window() { + if (gui) { + return gui->get_window(); + } + return nullptr; + } + +private: + uint32_t sample_rate; + std::vector notes; + PluginGUI *gui; +}; + +static const char *features[] = { + CLAP_PLUGIN_FEATURE_INSTRUMENT, + CLAP_PLUGIN_FEATURE_SYNTHESIZER, + CLAP_PLUGIN_FEATURE_STEREO, + NULL, +}; + +static const clap_plugin_descriptor_t plugin_descriptor = {CLAP_VERSION_INIT, + "pluto.pgpl.test", + "PGPL Plugin Test", + "Patrick_Pluto", + "", + "", + "", + "1.0.0", + "Testing", + features}; + +static const clap_plugin_note_ports_t note_ports = { + [](const clap_plugin_t *, bool is_input) -> uint32_t { + return is_input ? 1 : 0; + }, + + [](const clap_plugin_t *, uint32_t index, bool isInput, + clap_note_port_info_t *info) -> bool { + if (!isInput || index) + return false; + info->id = 0; + info->supported_dialects = CLAP_NOTE_DIALECT_CLAP; + info->preferred_dialect = CLAP_NOTE_DIALECT_CLAP; + strncpy(info->name, "Note Input", sizeof(info->name)); + return true; + }, +}; + +static const clap_plugin_audio_ports_t audio_ports = { + [](const clap_plugin_t *, bool is_input) -> uint32_t { + return is_input ? 0 : 1; + }, + + [](const clap_plugin_t *, uint32_t index, bool isInput, + clap_audio_port_info_t *info) -> bool { + if (isInput || index) + return false; + info->id = 0; + info->channel_count = 2; + info->flags = CLAP_AUDIO_PORT_IS_MAIN; + info->port_type = CLAP_PORT_STEREO; + info->in_place_pair = CLAP_INVALID_ID; + strncpy(info->name, "Audio Output", sizeof(info->name)); + return true; + }, +}; + +static const clap_plugin_gui_t gui = { + [](const clap_plugin_t *, const char *api, bool is_floating) -> bool { +#ifdef __WIN32__ + if (strcmp(api, CLAP_WINDOW_API_WIN32) == 0 && !is_floating) { +#else + if (strcmp(api, CLAP_WINDOW_API_X11) == 0 && !is_floating) { +#endif + return true; + } + return false; + }, + + [](const clap_plugin_t *, const char **api, bool *is_floating) -> bool { +#ifdef __WIN32__ + *api = CLAP_WINDOW_API_WIN32; +#else + *api = CLAP_WINDOW_API_X11; +#endif + *is_floating = false; + return true; + }, + + [](const clap_plugin_t *plugin, const char *api, bool is_floating) -> bool { +#ifdef __WIN32__ + if (strcmp(api, CLAP_WINDOW_API_WIN32) == 0 && !is_floating) { +#else + if (strcmp(api, CLAP_WINDOW_API_X11) == 0 && !is_floating) { +#endif + PluginState *state = (PluginState *)plugin->plugin_data; + state->create_window(); + return true; + } + return false; + }, + + [](const clap_plugin_t *plugin) { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_destroy(state->get_window()); + state->destroy_window(); + }, + + [](const clap_plugin_t *plugin, double scale) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_set_scale(state->get_window(), scale); + return true; + }, + + [](const clap_plugin_t *plugin, uint32_t *width, uint32_t *height) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_get_size(state->get_window(), width, height); + return true; + }, + + [](const clap_plugin_t *) -> bool { return true; }, + + [](const clap_plugin_t *, clap_gui_resize_hints_t *) -> bool { + return false; + }, + + [](const clap_plugin_t *, uint32_t *, uint32_t *) -> bool { return true; }, + + [](const clap_plugin_t *plugin, uint32_t width, uint32_t height) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_set_size(state->get_window(), width, height); + return true; + }, + + [](const clap_plugin_t *plugin, const clap_window_t *window) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; +#ifdef __WIN32__ + pgpl_window_thread_reparent_to(state->get_window(), + (void *)window->win32); +#else + pgpl_window_thread_reparent_to(state->get_window(), (void *)&window->x11); +#endif + return true; + }, + + [](const clap_plugin_t *plugin, const clap_window_t *window) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; +#ifdef __WIN32__ + pgpl_window_thread_set_transient(state->get_window(), + (void *)window->win32); +#else + pgpl_window_thread_set_transient(state->get_window(), + (void *)&window->x11); +#endif + return true; + }, + + [](const clap_plugin_t *plugin, const char *title) { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_set_title(state->get_window(), title); + }, + + [](const clap_plugin_t *plugin) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_show(state->get_window()); + return true; + }, + + [](const clap_plugin_t *plugin) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; + pgpl_window_thread_hide(state->get_window()); + return true; + }, +}; + +static const clap_plugin_t plugin_class = { + &plugin_descriptor, + nullptr, + [](const clap_plugin *) -> bool { return true; }, + + [](const clap_plugin *plugin) { + delete (PluginState *)plugin->plugin_data; + delete plugin; + }, + + [](const clap_plugin *plugin, double sample_rate, uint32_t, + uint32_t) -> bool { + PluginState *state = (PluginState *)plugin->plugin_data; + state->set_sample_rate(sample_rate); + return true; + }, + + [](const clap_plugin *) {}, + + [](const clap_plugin *) -> bool { return true; }, + + [](const clap_plugin *) {}, + + [](const clap_plugin *) {}, + + [](const clap_plugin *plugin, + const clap_process_t *process) -> clap_process_status { + PluginState *state = (PluginState *)plugin->plugin_data; + + uint32_t event_amount = process->in_events->size(process->in_events); + uint32_t event_index = 0; + uint32_t next_event_frame = event_amount ? 0 : process->frames_count; + + for (uint32_t i = 0; i < process->frames_count;) { + while (event_index < event_amount && next_event_frame == i) { + const clap_event_header_t *event = + process->in_events->get(process->in_events, event_index); + + if (event->time != i) { + next_event_frame = event->time; + break; + } + + state->process_event(event); + event_index++; + + if (event_index == event_amount) { + next_event_frame = process->frames_count; + break; + } + } + + state->render_audio(process->audio_outputs[0].data32[0] + i, + process->audio_outputs[0].data32[1] + i, + next_event_frame - i); + i = next_event_frame; + } + + return CLAP_PROCESS_CONTINUE; + }, + + [](const clap_plugin *, const char *id) -> const void * { + if (0 == strcmp(id, CLAP_EXT_NOTE_PORTS)) + return ¬e_ports; + if (0 == strcmp(id, CLAP_EXT_AUDIO_PORTS)) + return &audio_ports; + if (0 == strcmp(id, CLAP_EXT_GUI)) + return &gui; + return nullptr; + }, + + [](const clap_plugin *) {}, +}; + +static const clap_plugin_factory_t plugin_factory = { + [](const clap_plugin_factory *) -> uint32_t { return 1; }, + + [](const clap_plugin_factory *, + uint32_t index) -> const clap_plugin_descriptor_t * { + return index == 0 ? &plugin_descriptor : nullptr; + }, + + [](const clap_plugin_factory *, const clap_host_t *host, + const char *plugin_id) -> const clap_plugin_t * { + if (!clap_version_is_compatible(host->clap_version) || + strcmp(plugin_id, plugin_descriptor.id)) { + return nullptr; + } + + clap_plugin_t *plugin = new clap_plugin_t(plugin_class); + plugin->plugin_data = new PluginState(); + + return plugin; + }, +}; + +extern "C" const clap_plugin_entry_t clap_entry = { + CLAP_VERSION_INIT, + [](const char *plugin_path) -> bool { + pgpl_init(); + srand(time(NULL)); + font_path = new std::string(plugin_path + std::string(".ttf")); + return true; + }, + []() { + delete font_path; + pgpl_deinit(); + }, + [](const char *factory_id) -> const void * { + return strcmp(factory_id, CLAP_PLUGIN_FACTORY_ID) ? nullptr + : &plugin_factory; + }, +}; diff --git a/tests/program.c b/tests/program.c new file mode 100644 index 0000000..fb86688 --- /dev/null +++ b/tests/program.c @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include + +struct AppData { + int counter; + char counter_buffer[128]; + PGPL_Gui *gui; +}; + +static void on_counter_button_click(void *data) { + struct AppData *app = data; + app->counter++; + snprintf(app->counter_buffer, sizeof(app->counter_buffer), "%d", + app->counter); + + if (app->counter % 10 == 0) { + pgpl_gui_theme_configure( + &app->gui->theme, + pgpl_color_create(rand() % 256, rand() % 256, rand() % 256, 255), 48, + app->gui->theme.font); + } +} + +static void configure_widget_default(PGPL_GuiWidget *widget) { + pgpl_gui_widget_configure(widget, 0, 0, true, true, true, true, + PGPL_GUI_FONT_SIZE_CONTENT, NULL, false, false, + false, false); +} + +PGPL_GuiWidget *create_main_view(struct AppData *app) { + PGPL_GuiContainerLayout *column_layout; + PGPL_GuiButtonWidget *counter_button; + PGPL_GuiTextWidget *counter; + + column_layout = pgpl_gui_container_layout_create( + PGPL_GUI_CONTAINER_LAYOUT_DIRECTION_VERTICAL); + pgpl_gui_widget_configure(&column_layout->parent, 0, 0, true, true, false, + false, PGPL_GUI_FONT_SIZE_CONTENT, NULL, false, + true, true, false); + + counter_button = + pgpl_gui_button_widget_create("Click me!", on_counter_button_click); + configure_widget_default(&counter_button->parent); + + counter = pgpl_gui_text_widget_create(app->counter_buffer); + configure_widget_default(&counter->parent); + counter->parent.font_size = PGPL_GUI_FONT_SIZE_TITLE; + counter->parent.background = false; + counter->parent.border = false; + + pgpl_gui_container_layout_widget_add(column_layout, &counter->parent); + pgpl_gui_container_layout_widget_add(column_layout, &counter_button->parent); + + return (PGPL_GuiWidget *)column_layout; +} + +int32_t main(void) { + PGPL_Gui *gui; + PGPL_GuiTheme theme; + PGPL_Font *font; + struct AppData app; + + pgpl_init(); + + srand(time(NULL)); + + strcpy(app.counter_buffer, "0"); + app.counter = 0; + + font = pgpl_font_create_from_file("../roboto.ttf", 256); + + pgpl_gui_theme_configure(&theme, pgpl_color_create(255, 255, 255, 255), 48, + font); + + gui = pgpl_gui_create("PGPL Test", 320, 320, 0, 0, &theme, &app); + + app.gui = gui; + + pgpl_gui_widget_add(gui, create_main_view(&app)); + + pgpl_gui_run_and_show(gui, true); + + pgpl_font_destroy(NULL, font); + + pgpl_deinit(); + + return 0; +} diff --git a/todo.md b/todo.md new file mode 100644 index 0000000..acd4f70 --- /dev/null +++ b/todo.md @@ -0,0 +1,23 @@ +# TODO + +Farther Blockers: +Translate keymaps properly so that they can be used by programs. +Further error handling on X11, Win32 API and more. +Logging library for this error handling, so that outputs can be supressed. (or remove the current prints...) + +Fun Features: + +- Allow not automatically freeing +- get the framerate controllable and gettable, and then we can get animations. +- Allow resizing the window with the scale. +- More rendering functions +- Cursor change +- Allow changing the window minimum and maximum size. +- Lock a windows aspect ratio (and autoscale) +- Switch widget (left and right buttons to go through the entries, with their names being displayed) +- Text input widget +- Intended OpenGL interface. +- Testing suite. +- Checkbox Widget +- System Font loading. +- Make the Vector thread safe.

kKH~W?c845P6D*_Z(<;I1!I;NNxzbmK`8`k! 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