@hxa-rn/react-native-gcanvas 6.0.24-beta.1

package/harmony/gcanvas/src/main/cpp/core/src/support/DynArray.h

@@ -0,0 +1,157 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef GCANVAS_DYNARRAY_H
+#define GCANVAS_DYNARRAY_H
+
+#include <cstdlib>
+
+#ifdef DEBUG
+void DLog(const char *format, ...);
+#ifdef __ANDROID__
+#define ASSERT(x)                                                              \
+    {                                                                          \
+        if (!(x))                                                              \
+        {                                                                      \
+            gErrorFlag = true;                                                 \
+            DLog("ASSERT %s:%d %s", __FILE__, __LINE__, #x);                   \
+        }                                                                      \
+    }
+#else
+#include <assert.h>
+#define ASSERT(x)                                                              \
+    {                                                                          \
+        assert(x);                                                             \
+    }
+#endif
+#else
+#ifndef ASSERT
+#define ASSERT(x)                                                              \
+    {                                                                          \
+    }
+#endif
+#endif
+
+template < class T > class DynArray
+{
+public:
+    DynArray(unsigned int initialSize = (unsigned int)kInitialMemSize);
+    virtual ~DynArray();
+
+    const T &operator[](int i) const
+    {
+        ASSERT(i < m_size);
+        ASSERT(m_size <= m_allocatedSize);
+        return m_entries[i];
+    }
+    T &operator[](int i)
+    {
+        ASSERT(i < m_size);
+        return m_entries[i];
+    }
+
+    int GetSize() const
+    {
+        ASSERT(m_size <= m_allocatedSize);
+        return m_size;
+    }
+    void SetSize(int size);
+    bool IsEmpty() const { return (m_size == 0); }
+
+    void Append(const T *entries, int len);
+    void RemoveAt(int index);
+
+    T *GetData() { return m_entries; }
+    const T *GetData() const { return m_entries; }
+
+private:
+    DynArray(const DynArray &that);            // private, undefined
+    DynArray &operator=(const DynArray &that); // private, undefined
+
+    enum
+    {
+        kInitialMemSize = 8
+    };
+    T *m_entries;
+    int m_size;
+    int m_allocatedSize;
+};
+
+template < class T > DynArray< T >::DynArray(unsigned int initialSize)
+{
+    m_size = m_allocatedSize = 0;
+    m_entries = NULL;
+    SetSize(initialSize);
+    SetSize(0);
+}
+
+template < class T > DynArray< T >::~DynArray()
+{
+    if (m_entries)
+    {
+        free(m_entries);
+        m_entries = NULL;
+        m_size = 0;
+        m_allocatedSize = 0;
+    }
+}
+
+template < class T > void DynArray< T >::Append(const T *entries, int len)
+{
+    if (entries && len)
+    {
+        unsigned int base = m_size;
+        SetSize(m_size + len);
+        memcpy(m_entries + base, entries, len * sizeof(T));
+    }
+}
+
+template < class T > void DynArray< T >::RemoveAt(int index)
+{
+    ASSERT(index < m_size);
+    if (index < (m_size - 1))
+    {
+        memmove(&m_entries[index], &m_entries[index + 1],
+                (m_size - (index + 1)) * sizeof(T));
+    }
+    m_size--;
+}
+
+template < class T > void DynArray< T >::SetSize(int size)
+{
+    ASSERT(size >= 0);
+    if (size > m_allocatedSize)
+    {
+        // Really need to guarantee power of 2 for VBOs.
+        int newSize = 16;
+        while (newSize < size)
+        {
+            newSize *= 2;
+        }
+        // m_entries = (T *) realloc (m_entries, newSize * sizeof(T));
+        // ASSERT(m_entries);
+        T *newEntries = (T *)realloc(m_entries, newSize * sizeof(T));
+        if (newEntries)
+        {
+            m_entries = newEntries;
+        }
+        else
+        { // could not realloc, but orig still valid
+            ASSERT(newEntries);
+        }
+
+        memset(m_entries + m_allocatedSize, 0,
+               (newSize - m_allocatedSize) * sizeof(T));
+        m_allocatedSize = newSize;
+    }
+
+    m_size = size;
+    ASSERT(m_size < 10 * 1000); // sanity check.
+}
+
+#endif /* GCANVAS_DYNARRAY_H */

package/harmony/gcanvas/src/main/cpp/core/src/support/Encode.cpp

@@ -0,0 +1,116 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include "Encode.h"
+
+namespace gcanvas
+{
+static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                     "abcdefghijklmnopqrstuvwxyz"
+                                     "0123456789+/";
+static const unsigned char BASE64_INDEXES[] = {
+    62,  255, 255, 255, 63,  52,  53, 54, 55, 56, 57, 58, 59, 60, 61, 255,
+    255, 255, 255, 255, 255, 255, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+    10,  11,  12,  13,  14,  15,  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+    255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+    36,  37,  38,  39,  40,  41,  42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
+
+static const char BASE64_PAD = '=';
+static const char BASE64_FIRST = '+';
+
+#define CSHL(v, n) ((unsigned char)((v) << (n)))
+#define CSHR(v, n) ((unsigned char)((v) >> (n)))
+#define CSHLR(v, l, r) CSHR(CSHL(v, l), r)
+#define CSHRL(v, r, l) CSHL(CSHR(v, r), l)
+#define DECODE(v) (BASE64_INDEXES[(v)-BASE64_FIRST])
+
+int Base64EncodeLen(int inputLen) { return (inputLen + 2) / 3 * 4; }
+
+int Base64EncodeBuf(char *szDest, const char *szSrc, int &iBufSize)
+{
+    unsigned char *output = (unsigned char *)szDest;
+    const unsigned char *input = (const unsigned char *)szSrc;
+
+    int ret = 0;
+    for (int i = 0; i < iBufSize; i += 3)
+    {
+        output[ret++] = BASE64_CHARS[CSHR(input[i], 2)];
+
+        if (i + 1 >= iBufSize)
+        {
+            output[ret] = BASE64_CHARS[CSHLR(input[i], 6, 2)];
+            output[++ret] = BASE64_PAD;
+            output[++ret] = BASE64_PAD;
+            ++ret;
+            break;
+        }
+
+        output[ret] =
+            BASE64_CHARS[CSHLR(input[i], 6, 2) | CSHR(input[i + 1], 4)];
+        if (i + 2 >= iBufSize)
+        {
+            output[++ret] = BASE64_CHARS[CSHLR(input[i + 1], 4, 2)];
+            output[++ret] = BASE64_PAD;
+            ++ret;
+            break;
+        }
+        output[++ret] =
+            BASE64_CHARS[CSHLR(input[i + 1], 4, 2) | CSHR(input[i + 2], 6)];
+        output[++ret] = BASE64_CHARS[CSHLR(input[i + 2], 2, 2)];
+        ++ret;
+    }
+    iBufSize = ret;
+    return iBufSize;
+}
+
+int Base64DecodeBuf(char *szDest, const char *szSrc, int &iBufSize)
+{
+    unsigned char *output = (unsigned char *)szDest;
+    const unsigned char *input = (const unsigned char *)szSrc;
+
+    if (iBufSize % 4 > 0)
+    {
+        return -1;
+    }
+
+    int ret = 0;
+    for (int i = 0; i < iBufSize; i += 4)
+    {
+        unsigned char buf[4] = {0};
+        for (int j = 0; j < 4; ++j)
+        {
+            if (input[i + j] == BASE64_PAD)
+            {
+                break;
+            }
+            buf[j] = DECODE(input[i + j]);
+        }
+
+        buf[0] <<= 2;
+        output[ret++] = buf[0] | CSHR(buf[1], 4);
+
+        if (BASE64_PAD == input[i + 2])
+        {
+            break;
+        }
+
+        buf[1] <<= 4;
+        output[ret++] = buf[1] | CSHR(buf[2], 2);
+
+        if (BASE64_PAD == input[i + 3])
+        {
+            break;
+        }
+
+        buf[2] <<= 6;
+        output[ret++] = buf[2] | buf[3];
+    }
+    iBufSize = ret;
+    return iBufSize;
+}
+}

package/harmony/gcanvas/src/main/cpp/core/src/support/Encode.h

@@ -0,0 +1,20 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef GCANVAS_ENCODE_H
+#define GCANVAS_ENCODE_H
+
+namespace gcanvas
+{
+////////////////////////////base64 encoding////////////////////////////
+int Base64EncodeLen(int inputLen);
+int Base64EncodeBuf(char *szDest, const char *szSrc, int &iBufSize);
+int Base64DecodeBuf(char *szDest, const char *szSrc, int &iBufSize);
+}
+
+#endif /* GCANVAS_ENCODE_H */

package/harmony/gcanvas/src/main/cpp/core/src/support/FileUtils.cpp

@@ -0,0 +1,153 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include "FileUtils.h"
+
+#include <stack>
+#include <stdlib.h>
+
+FileUtils *FileUtils::s_sharedFileUtils = nullptr;
+
+FileUtils *FileUtils::GetInstance()
+{
+    if (!s_sharedFileUtils) s_sharedFileUtils = new FileUtils();
+    return s_sharedFileUtils;
+}
+
+void FileUtils::DestroyInstance() { GC_SAFE_DELETE(s_sharedFileUtils); }
+
+FileUtils::FileUtils() {}
+
+FileUtils::~FileUtils() {}
+
+unsigned char *FileUtils::GetFileData(const std::string &filename,
+                                      const char *mode, size_t *size)
+{
+    unsigned char *buffer = nullptr;
+    *size = 0;
+    do
+    {
+        const std::string fullPath = fullPathForFilename(filename);
+        FILE *fp = fopen(fullPath.c_str(), mode);
+        GC_BREAK_IF(!fp);
+
+        fseek(fp, 0, SEEK_END);
+        *size = ftell(fp);
+        fseek(fp, 0, SEEK_SET);
+        buffer = (unsigned char *)malloc(*size);
+        *size = fread(buffer, sizeof(unsigned char), *size, fp);
+        fclose(fp);
+    } while (0);
+
+    return buffer;
+}
+
+size_t FileUtils::WriteFileData(const std::string &filename, const char *data,
+                             size_t size)
+{
+    size_t ret = -1;
+    do
+    {
+        FILE *fp = fopen(filename.c_str(), "wb");
+        if (fp == NULL)
+        {
+            break;
+        }
+
+        ret = fwrite(data, size, sizeof(char), fp);
+
+        fclose(fp);
+    } while (0);
+
+    return ret;
+}
+
+std::string FileUtils::getNewFilename(const std::string &filename) const
+{
+    std::string newFileName;
+
+    auto iter = mFilenameLookupDict.find(filename);
+
+    if (iter == mFilenameLookupDict.end())
+    {
+        newFileName = filename;
+    }
+    else
+    {
+        newFileName = iter->second.asString();
+    }
+    return newFileName;
+}
+
+std::string
+FileUtils::getPathForFilename(const std::string &filename,
+                              const std::string &resolutionRenderer,
+                              const std::string &searchPath)
+{
+    std::string file = filename;
+    std::string filePath = "";
+    size_t pos = filename.find_last_of("/");
+    if (pos != std::string::npos)
+    {
+        filePath = filename.substr(0, pos + 1);
+        file = filename.substr(pos + 1);
+    }
+
+    std::string path = searchPath;
+    path += filePath;
+    path += resolutionRenderer;
+
+    return path;
+}
+
+std::string FileUtils::fullPathForFilename(const std::string &filename)
+{
+    if (filename.empty())
+    {
+        return "";
+    }
+
+    if (isAbsolutePath(filename))
+    {
+        return filename;
+    }
+
+    auto cacheIter = mFullPathCache.find(filename);
+    if (cacheIter != mFullPathCache.end())
+    {
+        return cacheIter->second;
+    }
+
+    const std::string newFilename(getNewFilename(filename));
+
+    std::string fullPath;
+
+    for (auto searchIt = mSearchPathArray.begin();
+         searchIt != mSearchPathArray.end(); ++searchIt)
+    {
+        for (auto resolutionIt = mSearchResolutionsOrderArray.begin();
+             resolutionIt != mSearchResolutionsOrderArray.end(); ++resolutionIt)
+        {
+            fullPath =
+                this->getPathForFilename(newFilename, *resolutionIt, *searchIt);
+
+            if (fullPath.length() > 0)
+            {
+                mFullPathCache.insert(std::make_pair(filename, fullPath));
+                return fullPath;
+            }
+        }
+    }
+
+    return filename;
+}
+
+bool FileUtils::isAbsolutePath(const std::string &path) const
+{
+    return (path[0] == '/');
+}

package/harmony/gcanvas/src/main/cpp/core/src/support/FileUtils.h

@@ -0,0 +1,56 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef __GCANVAS_FILEUTILS_H__
+#define __GCANVAS_FILEUTILS_H__
+
+#include <string>
+#include <vector>
+#include <map>
+#include "Value.h"
+
+class FileUtils
+{
+public:
+    static FileUtils *GetInstance();
+    static void DestroyInstance();
+
+    virtual ~FileUtils();
+
+    virtual unsigned char *GetFileData(const std::string &filename,
+                                       const char *mode, size_t *size);
+    virtual size_t WriteFileData(const std::string &filename, const char *data,
+                              size_t size);
+    virtual std::string fullPathForFilename(const std::string &filename);
+
+    virtual bool isAbsolutePath(const std::string &path) const;
+
+    const std::map< std::string, std::string > &GetFullPathCache() const
+    {
+        return mFullPathCache;
+    }
+
+protected:
+
+    FileUtils();
+
+    virtual std::string getNewFilename(const std::string &filename) const;
+
+    virtual std::string
+    getPathForFilename(const std::string &filename,
+                       const std::string &resolutionRenderer,
+                       const std::string &searchPath);
+
+    ValueMap mFilenameLookupDict;
+    std::vector< std::string > mSearchResolutionsOrderArray;
+    std::vector< std::string > mSearchPathArray;
+    std::map< std::string, std::string > mFullPathCache;
+    static FileUtils *s_sharedFileUtils;
+};
+
+#endif

package/harmony/gcanvas/src/main/cpp/core/src/support/GLUtil.cpp

@@ -0,0 +1,174 @@
+/**
+* Created by G-Canvas Open Source Team.
+* Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+*
+* This source code is licensed under the Apache Licence 2.0.
+* For the full copyright and license information, please view
+* the LICENSE file in the root directory of this source tree.
+*/
+
+#include "GLUtil.h"
+
+namespace gcanvas {
+
+
+//////////////////////////////////////////////////////////////////////////////
+///   Pixels Sample
+//////////////////////////////////////////////////////////////////////////////
+    struct RGBA {
+        RGBA &operator+=(int c) {
+            r += c & 0xff;
+            g += c >> 8 & 0xff;
+            b += c >> 16 & 0xff;
+            a += c >> 24 & 0xff;
+
+            return *this;
+        }
+
+        operator uint32_t() {
+            uint32_t c = 0;
+            c += r & 0xff;
+            c += g << 8 & 0xff00;
+            c += b << 16 & 0xff0000;
+            c += a << 24 & 0xff000000;
+
+            return c;
+        }
+
+        uint16_t r = 0;
+        uint16_t g = 0;
+        uint16_t b = 0;
+        uint16_t a = 0;
+    };
+
+    inline RGBA operator/(const RGBA &a, int b) {
+        RGBA c;
+        c.r = a.r / b;
+        c.g = a.g / b;
+        c.b = a.b / b;
+        c.a = a.a / b;
+        return c;
+    }
+
+    inline int GetPixel(int *pixels, int x, int y, int width, int height) {
+        if (x < 0) {
+            x = 0;
+        }
+        if (x > width - 1) {
+            x = width - 1;
+        }
+        if (y < 0) {
+            y = 0;
+        }
+        if (y > height - 1) {
+            y = height - 1;
+        }
+        return pixels[y * width + x];
+    }
+
+    void PixelsSampler(int inWidth, int inHeight, int *inPixels, int outWidth, int outHeight,
+                       int *outPixels, bool imageSmoothingEnabled) {
+        if (outWidth == 1 && outHeight == 1) {
+            // when GetImageData 1x1 , it means APP want color pick 1 pixel, so
+            // it's better not `pixel / 9` below but just pick 1 pixel exactly
+            // in PixelsSampler() after GCanvasContext::GetImageData(), and since
+            // float x y from PanResponder event which be divided by devicePixelRatio
+            // (so that can be float), is converted to int x y in GCanvasWeex::GetImageData(),
+            // so the exact pixel is inPixels[left bottom] while considering flip Y
+            int inY = 0;
+            int revertY = (inHeight - 1) - inY; // bottom is (3 - 1) - 0 = 2
+            int inX = 0; // left is 0
+            outPixels[0] = GetPixel(inPixels, inX, revertY, inWidth, inHeight);
+        } else {
+            float scaleWidth = inWidth / outWidth;
+            float offsetX = scaleWidth / 2;
+            if (scaleWidth < 2) {
+                // can't find an offsetX to PixelsSampler without a flaw for 1 < scaleWidth < 2 , so just 0
+                offsetX = 0;
+            }
+
+            float scaleHeight = inHeight / outHeight;
+            float offsetY = scaleHeight / 2;
+            if (scaleHeight < 2) {
+                offsetX = 0;
+            }
+
+            for (int y = 0; y < outHeight; ++y) {
+                // here inHeight / outHeight is more accurate than scaleHeight for inY
+                int inY = y * inHeight / outHeight + offsetY;
+                int revertY = (inHeight - 1) - inY;
+                for (int x = 0; x < outWidth; ++x) {
+                    int inX = x * inWidth / outWidth + offsetX;
+                    if (imageSmoothingEnabled) {
+                        RGBA pixel;
+                        pixel += GetPixel(inPixels, inX, revertY, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX - 1, revertY - 1, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX, revertY - 1, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX + 1, revertY - 1, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX - 1, revertY, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX + 1, revertY, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX - 1, revertY + 1, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX, revertY + 1, inWidth, inHeight);
+                        pixel += GetPixel(inPixels, inX - 1, revertY + 1, inWidth, inHeight);
+                        outPixels[y * outWidth + x] = pixel / 9;
+                    } else {
+                        outPixels[y * outWidth + x] = GetPixel(inPixels, inX, revertY, inWidth, inHeight);
+                    }
+                }
+            }
+        }
+    }
+
+//////////////////////////////////////////////////////////////////////////////
+///   Pixels BindTexture
+//////////////////////////////////////////////////////////////////////////////
+    GLuint PixelsBindTexture(const unsigned char *rgbaData, GLint format, unsigned int width,
+                             unsigned int height, bool imageSmoothingEnabled,
+                             std::vector<GCanvasLog> *errVec) {
+        if (nullptr == rgbaData)
+            return (GLuint) - 1;
+
+        GLenum glerror = 0;
+        GLuint glID;
+        glGenTextures(1, &glID);
+        glerror = glGetError();
+        if (glerror && errVec) {
+            GCanvasLog log;
+            fillLogInfo(log, "gen_texture_fail", "<function:%s, glGetError:%x>", __FUNCTION__,
+                        glerror);
+            errVec->push_back(log);
+        }
+        glBindTexture(GL_TEXTURE_2D, glID);
+        glerror = glGetError();
+        if (glerror && errVec) {
+            GCanvasLog log;
+            fillLogInfo(log, "bind_texture_fail", "<function:%s, glGetError:%x>", __FUNCTION__,
+            glerror);
+            errVec->push_back(log);
+        }
+
+        if (imageSmoothingEnabled) {
+            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        } else {
+            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        }
+
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format,
+                     GL_UNSIGNED_BYTE, rgbaData);
+        glerror = glGetError();
+        if (glerror && errVec) {
+            GCanvasLog log;
+            fillLogInfo(log, "glTexImage2D_failglTexImage2D_fail", "<function:%s, glGetError:%x>",
+            __FUNCTION__, glerror);
+            errVec->push_back(log);
+        }
+
+        return glID;
+    }
+
+}

package/harmony/gcanvas/src/main/cpp/core/src/support/GLUtil.h

@@ -0,0 +1,25 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef GCANVAS_GLUTIL_H
+#define GCANVAS_GLUTIL_H
+
+#include "../gcanvas/GGL.h"
+#include "../support/Log.h"
+#include <vector>
+
+namespace gcanvas{
+    GLuint PixelsBindTexture(const unsigned char *rgbaData, GLint format, unsigned int width,
+                             
+                             unsigned int height, bool imageSmoothingEnabled = true,
+                             std::vector<GCanvasLog> *errVec = nullptr);
+    void PixelsSampler(int inWidth, int inHeight, int *inPixels, int outWidth, int outHeight, int *outPixels, bool imageSmoothingEnabled = true);
+}
+
+#endif /* GCANVAS_GLUTIL_H */