react-native-nitro-xlsx 0.2.5 → 0.2.7

package/thirdparty/miniz/examples/example6.c

@@ -0,0 +1,189 @@
+// example6.c - Demonstrates how to miniz's PNG writer func
+// Public domain, April 11 2012, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// Mandlebrot set code from http://rosettacode.org/wiki/Mandelbrot_set#C
+// Must link this example against libm on Linux.
+
+// Purposely disable a whole bunch of stuff this low-level example doesn't use.
+#define MINIZ_NO_STDIO
+#define MINIZ_NO_TIME
+#define MINIZ_NO_ZLIB_APIS
+#include "miniz.h"
+
+// Now include stdio.h because this test uses fopen(), etc. (but we still don't want miniz.c's stdio stuff, for testing).
+#include <stdio.h>
+#include <limits.h>
+#include <math.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+typedef struct
+{
+    uint8 r, g, b;
+} rgb_t;
+
+static void hsv_to_rgb(int hue, int min, int max, rgb_t *p)
+{
+    const int invert = 0;
+    const int saturation = 1;
+    const int color_rotate = 0;
+
+    if (min == max)
+        max = min + 1;
+    if (invert)
+        hue = max - (hue - min);
+    if (!saturation)
+    {
+        p->r = p->g = p->b = 255 * (max - hue) / (max - min);
+        return;
+    }
+    else
+    {
+        const double h_dbl = fmod(color_rotate + 1e-4 + 4.0 * (hue - min) / (max - min), 6);
+        const double c_dbl = 255 * saturation;
+        const double X_dbl = c_dbl * (1 - fabs(fmod(h_dbl, 2) - 1));
+        const int h = (int)h_dbl;
+        const int c = (int)c_dbl;
+        const int X = (int)X_dbl;
+
+        p->r = p->g = p->b = 0;
+
+        switch (h)
+        {
+            case 0:
+                p->r = c;
+                p->g = X;
+                return;
+            case 1:
+                p->r = X;
+                p->g = c;
+                return;
+            case 2:
+                p->g = c;
+                p->b = X;
+                return;
+            case 3:
+                p->g = X;
+                p->b = c;
+                return;
+            case 4:
+                p->r = X;
+                p->b = c;
+                return;
+            default:
+                p->r = c;
+                p->b = X;
+        }
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    // Image resolution
+    const int iXmax = 4096;
+    const int iYmax = 4096;
+
+    // Output filename
+    static const char *pFilename = "mandelbrot.png";
+
+    int iX, iY;
+    const double CxMin = -2.5;
+    const double CxMax = 1.5;
+    const double CyMin = -2.0;
+    const double CyMax = 2.0;
+
+    double PixelWidth = (CxMax - CxMin) / iXmax;
+    double PixelHeight = (CyMax - CyMin) / iYmax;
+
+    // Z=Zx+Zy*i  ;   Z0 = 0
+    double Zx, Zy;
+    double Zx2, Zy2; // Zx2=Zx*Zx;  Zy2=Zy*Zy
+
+    int Iteration;
+    const int IterationMax = 200;
+
+    // bail-out value , radius of circle
+    const double EscapeRadius = 2;
+    double ER2 = EscapeRadius * EscapeRadius;
+
+    uint8 *pImage = (uint8 *)malloc(iXmax * 3 * iYmax);
+
+    // world ( double) coordinate = parameter plane
+    double Cx, Cy;
+
+    int MinIter = 9999, MaxIter = 0;
+
+    (void)argc, (void)argv;
+
+    for (iY = 0; iY < iYmax; iY++)
+    {
+        Cy = CyMin + iY * PixelHeight;
+        if (fabs(Cy) < PixelHeight / 2)
+            Cy = 0.0; // Main antenna
+
+        for (iX = 0; iX < iXmax; iX++)
+        {
+            uint8 *color = pImage + (iX * 3) + (iY * iXmax * 3);
+
+            Cx = CxMin + iX * PixelWidth;
+
+            // initial value of orbit = critical point Z= 0
+            Zx = 0.0;
+            Zy = 0.0;
+            Zx2 = Zx * Zx;
+            Zy2 = Zy * Zy;
+
+            for (Iteration = 0; Iteration < IterationMax && ((Zx2 + Zy2) < ER2); Iteration++)
+            {
+                Zy = 2 * Zx * Zy + Cy;
+                Zx = Zx2 - Zy2 + Cx;
+                Zx2 = Zx * Zx;
+                Zy2 = Zy * Zy;
+            };
+
+            color[0] = (uint8)Iteration;
+            color[1] = (uint8)Iteration >> 8;
+            color[2] = 0;
+
+            if (Iteration < MinIter)
+                MinIter = Iteration;
+            if (Iteration > MaxIter)
+                MaxIter = Iteration;
+        }
+    }
+
+    for (iY = 0; iY < iYmax; iY++)
+    {
+        for (iX = 0; iX < iXmax; iX++)
+        {
+            uint8 *color = (uint8 *)(pImage + (iX * 3) + (iY * iXmax * 3));
+
+            uint Iterations = color[0] | (color[1] << 8U);
+
+            hsv_to_rgb((int)Iterations, MinIter, MaxIter, (rgb_t *)color);
+        }
+    }
+
+    // Now write the PNG image.
+    {
+        size_t png_data_size = 0;
+        void *pPNG_data = tdefl_write_image_to_png_file_in_memory_ex(pImage, iXmax, iYmax, 3, &png_data_size, 6, MZ_FALSE);
+        if (!pPNG_data)
+            fprintf(stderr, "tdefl_write_image_to_png_file_in_memory_ex() failed!\n");
+        else
+        {
+            FILE *pFile = fopen(pFilename, "wb");
+            fwrite(pPNG_data, 1, png_data_size, pFile);
+            fclose(pFile);
+            printf("Wrote %s\n", pFilename);
+        }
+
+        // mz_free() is by default just an alias to free() internally, but if you've overridden miniz's allocation funcs you'll probably need to call mz_free().
+        mz_free(pPNG_data);
+    }
+
+    free(pImage);
+
+    return EXIT_SUCCESS;
+}

package/thirdparty/miniz/meson.build

@@ -0,0 +1,21 @@
+project('miniz', 'c')
+
+miniz_includes = include_directories('.')
+
+cfg = configuration_data()
+cfg.set('MINIZ_EXPORT', '')
+miniz_export_h = configure_file(output: 'miniz_export.h',
+                                configuration: cfg)
+
+libminiz = static_library('miniz',
+                          miniz_export_h, 'miniz.c', 'miniz_zip.c', 'miniz_tinfl.c', 'miniz_tdef.c',
+                          include_directories: miniz_includes)
+
+miniz_dependency = declare_dependency(link_with: libminiz,
+                                      include_directories: miniz_includes)
+                                      
+miniz_dep = miniz_dependency # Compatibility for WrapDB users
+
+if meson.version().version_compare('>= 0.54.0')
+    meson.override_dependency('miniz', miniz_dep)
+endif