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

package/harmony/gcanvas/src/main/cpp/core/harmony/3d/view/grenderer.cpp

@@ -0,0 +1,677 @@
+#include <multimedia/image_framework/image/image_common.h>
+#include <multimedia/image_framework/image/pixelmap_native.h>
+#include <native_window/external_window.h>
+#include "grenderer.h"
+#include "Util.h"
+#include "Encode.h"
+#include "GCanvas2DContextHarmony.h"
+
+#include <climits>
+#include <cstdint>
+
+GRenderer::GRenderer(std::string key) : m_egl_context(0), m_egl_display(0), m_egl_surface(0), m_window(0) {
+    pthread_mutex_init(&m_mutex, 0);
+    sem_init(&m_SyncSem, 0, 0);
+    sem_init(&m_dummy, 0, 0);
+    this->mContextId = key;
+}
+
+GRenderer::~GRenderer() {
+    LOG_D("~GRenderer.");
+    if (m_threadCreated || mProxy != nullptr || m_egl_context != EGL_NO_CONTEXT ||
+        m_egl_surface != EGL_NO_SURFACE || m_egl_display != EGL_NO_DISPLAY) {
+        stop();
+    }
+    sem_destroy(&m_SyncSem);
+    sem_destroy(&m_dummy);
+    pthread_cond_destroy(&m_cond);
+    pthread_mutex_destroy(&m_mutex);
+}
+
+void GRenderer::setNativeWindow(OHNativeWindow *window) { m_window = window; }
+
+OHNativeWindow *GRenderer::getNativeWindow() { return m_window; }
+
+bool GRenderer::updateSurface(OHNativeWindow *window, uint64_t width, uint64_t height,
+                              const std::string &clearColor) {
+    pthread_mutex_lock(&m_mutex);
+    const bool changed = m_width != static_cast<int>(width) ||
+        m_height != static_cast<int>(height) || m_window != window;
+    if (changed) {
+        m_window = window;
+        m_width = static_cast<int>(width);
+        m_height = static_cast<int>(height);
+    }
+    if (!clearColor.empty()) {
+        mClearColor = StrValueToColorRGBA(clearColor.c_str());
+    }
+    pthread_mutex_unlock(&m_mutex);
+    return changed;
+}
+
+bool GRenderer::isStarted() const { return m_started.load(); }
+
+bool GRenderer::isReady() {
+    pthread_mutex_lock(&m_mutex);
+    const bool ready = m_started.load() && m_initialized && mProxy != nullptr;
+    pthread_mutex_unlock(&m_mutex);
+    return ready;
+}
+
+void GRenderer::initializeWebglExtensions() {
+    pthread_mutex_lock(&m_mutex);
+    if (mProxy != nullptr) {
+        mProxy->initWebglExt();
+    }
+    pthread_mutex_unlock(&m_mutex);
+}
+
+void GRenderer::setContextType(int type) {
+    pthread_mutex_lock(&m_mutex);
+    m_context_type = type;
+    if (mProxy != nullptr) {
+        mProxy->SetContextType(type);
+        mProxy->initWebglExt();
+    }
+    pthread_mutex_unlock(&m_mutex);
+}
+
+bool GRenderer::initialize() {
+    const EGLint attribs[] = {EGL_SURFACE_TYPE,
+                              EGL_WINDOW_BIT,
+                              EGL_BLUE_SIZE,
+                              8,
+                              EGL_GREEN_SIZE,
+                              8,
+                              EGL_RED_SIZE,
+                              8,
+                              EGL_ALPHA_SIZE,
+                              8,
+                              EGL_DEPTH_SIZE,
+                              16,
+                              EGL_RENDERABLE_TYPE,
+                              EGL_OPENGL_ES2_BIT,
+                              EGL_NONE};
+    EGLDisplay display;
+    EGLConfig config;
+    EGLint numConfigs;
+    EGLint format;
+    EGLSurface surface;
+    EGLContext context;
+    EGLint width;
+    EGLint height;
+    GLfloat ratio;
+
+
+    if (m_egl_display == EGL_NO_DISPLAY) {
+        if ((display = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY) {
+            destroy();
+            LOG_D("getdisplay failed.");
+            return false;
+        }
+        if (!eglInitialize(display, 0, 0)) {
+            destroy();
+            LOG_D("egl initialize failed.");
+            return false;
+        }
+
+    } else {
+        display = m_egl_display;
+    }
+
+    if (!eglChooseConfig(display, attribs, &config, 1, &numConfigs)) {
+        LOG_D("choose config failed.");
+        destroy();
+        return false;
+    }
+
+    if (!eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format)) {
+        LOG_D("get config failed.");
+        destroy();
+        return false;
+    }
+
+    if (m_egl_surface == EGL_NO_SURFACE) {
+//        OH_NativeWindow_NativeWindowHandleOpt(m_window, SET_BUFFER_GEOMETRY, 0, 0);
+        OH_NativeWindow_NativeWindowHandleOpt(m_window, SET_FORMAT, format);
+        if (!(surface = eglCreateWindowSurface(display, config, (EGLNativeWindowType)m_window, 0))) {
+            LOG_D("create surface failed.");
+            destroy();
+            return false;
+        }
+
+    } else {
+        surface = m_egl_surface;
+    }
+
+    if (m_egl_context == EGL_NO_CONTEXT) {
+        EGLint AttribList[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+        if (!(context = eglCreateContext(display, config, 0, AttribList))) {
+            LOG_D("create context failed.");
+            destroy();
+            return false;
+        }
+    } else {
+        context = m_egl_context;
+    }
+
+    if (!eglMakeCurrent(display, surface, surface, context)) {
+        LOG_D("make current failed.");
+        destroy();
+        return false;
+    }
+
+    if (!eglQuerySurface(display, surface, EGL_WIDTH, &width) ||
+        !eglQuerySurface(display, surface, EGL_HEIGHT, &height)) {
+        LOG_D("query surface failed.");
+        destroy();
+        return false;
+    }
+
+    m_egl_display = display;
+    m_egl_surface = surface;
+    m_egl_context = context;
+
+    glViewport(0, 0, width, height);
+
+    m_width = width;
+    m_height = height;
+
+    ratio = (GLfloat)width / height;
+
+    LOG_D("width=%d,height=%d,ratio=%f\n", m_width, m_height, ratio);
+    LOG_D("eglGetError coed:%d", eglGetError());
+    return true;
+}
+
+bool GRenderer::reInitialize() {
+    surfaceExit();
+    contextExit();
+    return initialize();
+}
+
+void GRenderer::start() {
+    if (m_threadCreated) {
+        return;
+    }
+    m_requestExit = false;
+    const int result = pthread_create(&m_thread_id, 0, threadStartCallback, this);
+    if (result == 0) {
+        m_threadCreated = true;
+    } else {
+        LOG_E("cannot create renderer thread, error=%d", result);
+    }
+}
+
+void GRenderer::stop() {
+
+    LOG_D("start to stop grenderer thread.");
+    pthread_mutex_lock(&m_mutex);
+    m_requestExit = true;
+    pthread_cond_signal(&m_cond);
+    pthread_mutex_unlock(&m_mutex);
+
+    LOG_D("nofity finished.");
+    if (m_threadCreated) {
+        LOG_D("join thread");
+        pthread_join(m_thread_id, 0);
+        m_threadCreated = false;
+    } else {
+        LOG_D("thread require exit on Stop");
+        if (mProxy) {
+            mProxy->setContextLost(true);
+            mProxy->setThreadExit();
+            mProxy->finishProc();
+        }
+
+        surfaceExit();
+        m_requestSurfaceDestroy = false;
+        m_initialized = false;
+
+        destroy();
+    }
+
+    LOG_D("finish stop thread.");
+}
+
+void GRenderer::destroy() {
+    GCanvasManager *m = GCanvasManager::GetManager();
+    m->RemoveCanvas(mContextId);
+    mProxy = nullptr;
+
+    contextExit();
+}
+
+void GRenderer::contextExit() {
+    LOG_D("context destroy in thread.");
+
+    if (m_egl_context != EGL_NO_CONTEXT && m_egl_display != EGL_NO_DISPLAY) {
+        LOG_D("context destroy start in thread.");
+        eglMakeCurrent(m_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        if (m_egl_surface != EGL_NO_SURFACE) {
+            eglDestroySurface(m_egl_display, m_egl_surface);
+        }
+        eglDestroyContext(m_egl_display, m_egl_context);
+        eglTerminate(m_egl_display);
+        m_egl_context = EGL_NO_CONTEXT;
+        m_egl_display = EGL_NO_DISPLAY;
+    }
+}
+
+void GRenderer::surfaceExit() {
+    LOG_D("surface destroy in thread.");
+    if (m_egl_display != EGL_NO_DISPLAY && m_egl_surface != EGL_NO_SURFACE) {
+        LOG_D("surface destroy start in thread.");
+        eglMakeCurrent(m_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglDestroySurface(m_egl_display, m_egl_surface);
+        m_egl_surface = EGL_NO_SURFACE;
+    }
+}
+
+void GRenderer::drawFrame() {
+    if (mProxy != nullptr) {
+        LOG_D("start to linkNativeGLProc.");
+        mProxy->LinkNativeGLProc();
+    }
+}
+
+void GRenderer::renderLoop() {
+    while (1) {
+
+        pthread_mutex_lock(&m_mutex);
+
+        if (m_requestExit) {
+            pthread_mutex_unlock(&m_mutex);
+            break;
+        }
+
+        if (!mProxy || (mProxy && !mProxy->continueProcess() && !m_viewportchanged && !m_requestSurfaceDestroy)) {
+            pthread_cond_wait(&m_cond, &m_mutex);
+        }
+
+        if (m_requestExit) {
+            pthread_mutex_unlock(&m_mutex);
+            break;
+        }
+
+
+        if (m_requestSurfaceDestroy && !m_requestExit) {
+            pthread_cond_wait(&m_cond, &m_mutex);
+        }
+
+        if (m_viewportchanged) {
+            if (!m_initialized) {
+                bool initResult = initialize();
+                m_initialized = initResult;
+                if (!initResult) {
+                    m_requestExit = true;
+                    pthread_mutex_unlock(&m_mutex);
+                    break;
+                }
+                if (mProxy)
+                    mProxy->setContextLost(false);
+            } else {
+                // need this, otherwise:
+                // 2d: will need 2nd ctx draw something to display right canvas size
+                // webgl: previous 3d object will display on somewhere
+                if (!reInitialize()) {
+                    m_initialized = false;
+                    m_requestExit = true;
+                    pthread_mutex_unlock(&m_mutex);
+                    break;
+                }
+
+                if (0 == mProxy->GetContextType()) {
+                    needDisableImageSmoothing = !mProxy->ImageSmoothingEnabled();
+                }
+                mProxy->ReCreateContext();
+                mProxy->SetContextType(m_context_type);
+            }
+
+            // OnSurfaceChanged below will invoke GCanvasContext::InitializeGLEnvironment()
+            // then invoke GCanvas2DContextAndroid::InitFBO() which need mEnableFboMsaa
+            // so that SetEnableFboMsaa before OnSurfaceChanged
+            ((GCanvas2DContextHarmony *)(mProxy->GetGCanvasContext()))->SetEnableFboMsaa(m_enableFboMsaa);
+
+            mProxy->OnSurfaceChanged(0, 0, m_width, m_height);
+
+            // OnSurfaceChanged above will invoke GCanvasContext::InitializeGLEnvironment()
+            // then invoke GCanvasContext::ResetStateStack() to init
+            // GCanvasContext->mCurrentState so that SetImageSmoothingEnabled below can
+            // set mCurrentState->mImageSmoothingEnabled
+            if (needDisableImageSmoothing && 0 == mProxy->GetContextType()) {
+                needDisableImageSmoothing = false;
+                mProxy->SetImageSmoothingEnabled(false);
+            }
+
+            mProxy->SetClearColor(mClearColor);
+            mProxy->SetDevicePixelRatio(m_device_pixel_ratio);
+            m_viewportchanged = false;
+
+            if (!m_requestInitialize) {
+                m_sendEvent = true;
+                m_requestInitialize = true;
+            }
+
+            sem_post(&m_SyncSem);
+        }
+
+
+        if (m_bindtexture && m_egl_surface != EGL_NO_SURFACE) {
+            mProxy->processAllBitmapQueue();
+            m_bindtexture = false;
+            sem_post(&m_SyncSem);
+        }
+
+        if (m_egl_display) {
+            drawFrame();
+            if (m_refresh) {
+                if (!eglSwapBuffers(m_egl_display, m_egl_surface)) {
+                    LOG_D("eglSwapBuffers failed, error: %d", eglGetError());
+                } else {
+                    LOG_D("eglSwapBuffers success");
+                }
+                m_refresh = false;
+            }
+        }
+
+        if (mProxy != nullptr) {
+            mProxy->finishProc();
+        }
+
+        pthread_mutex_unlock(&m_mutex);
+    }
+
+    if (m_requestExit) {
+        LOG_D("thread require exit.");
+        if (mProxy) {
+            mProxy->setContextLost(true);
+            mProxy->setThreadExit();
+            mProxy->finishProc();
+        }
+
+        surfaceExit();
+        m_requestSurfaceDestroy = false;
+        m_initialized = false;
+
+        destroy();
+    }
+}
+
+void *GRenderer::threadStartCallback(void *myself) {
+    GRenderer *renderer = (GRenderer *)myself;
+
+    renderer->m_started = true;
+    renderer->renderLoop();
+    renderer->m_started = false;
+    LOG_D("renderer thread exit.");
+    pthread_exit(0);
+}
+
+void GRenderer::signalUpGLthread() {
+    pthread_mutex_lock(&m_mutex);
+    pthread_cond_signal(&m_cond);
+    pthread_mutex_unlock(&m_mutex);
+}
+
+void GRenderer::setRefreshFlag(bool refresh) { m_refresh = refresh; }
+
+void GRenderer::requestCreateCanvas(const std::string contextid) {
+    mContextId = contextid;
+
+    if (!m_createCanvas) {
+        LOG_D("haven't created the canvas, creating...");
+        pthread_mutex_lock(&m_mutex);
+        if (!mProxy) {
+            mProxy = new GcanvasWeexOhos(mContextId, this);
+            mProxy->CreateContext();
+            mProxy->SetContextType(m_context_type);
+            GCanvasManager *m = GCanvasManager::GetManager();
+            m->AddCanvas(mProxy);
+            m_createCanvas = true;
+            m_sendEvent = true;
+        }
+        pthread_cond_signal(&m_cond);
+        pthread_mutex_unlock(&m_mutex);
+    } else {
+        LOG_D("already created the canvas");
+    }
+}
+
+void GRenderer::requestViewportChanged() {
+    LOG_D("requestViewportChanged");
+    pthread_mutex_lock(&m_mutex);
+    m_viewportchanged = true;
+    pthread_cond_signal(&m_cond);
+    pthread_mutex_unlock(&m_mutex);
+    waitUtilTimeout(&m_SyncSem, GCANVAS_TIMEOUT);
+}
+
+void GRenderer::drawImageData(int tw, int th, const std::string base64ImageData, int sx, int sy, int sw, int sh, int dx,
+                              int dy, int dw, int dh) {
+    if (tw <= 0 || th <= 0 ||
+        static_cast<size_t>(tw) > SIZE_MAX / static_cast<size_t>(th) ||
+        static_cast<size_t>(tw) * static_cast<size_t>(th) >
+            static_cast<size_t>(INT_MAX) / 4U || base64ImageData.empty()) {
+        LOG_E("drawImageData received invalid dimensions or pixels");
+        return;
+    }
+    const int buf_size = 4 * tw * th;
+    if (base64ImageData.size() != static_cast<size_t>(gcanvas::Base64EncodeLen(buf_size))) {
+        LOG_E("drawImageData encoded byte count mismatch");
+        return;
+    }
+
+    // std::string pixelsData;
+    // std::string *ptr_data = &pixelsData;
+    // ptr_data->resize(buf_size);
+    // char *pixels = (char *) ptr_data->c_str();
+    // TODO: Which is more efficient? std::string or malloc?
+    char *pixels = (char *)malloc(buf_size);
+    if (pixels == nullptr) {
+        LOG_E("drawImageData cannot allocate %d bytes", buf_size);
+        return;
+    }
+
+    int base64ImageDataLength = static_cast<int>(base64ImageData.size());
+    const int decodedLength = gcanvas::Base64DecodeBuf(pixels, base64ImageData.c_str(), base64ImageDataLength);
+    if (decodedLength != buf_size) {
+        free(pixels);
+        LOG_E("drawImageData decoded byte count mismatch");
+        return;
+    }
+
+    struct BitmapCmd *p = new struct BitmapCmd();
+    p->id = -1;
+    p->tw = tw;
+    p->th = th;
+    p->Bitmap = pixels;
+    p->sx = sx;
+    p->sy = sy;
+    p->sw = sw;
+    p->sh = sh;
+    p->dx = dx;
+    p->dy = dy;
+    p->dw = dw;
+    p->dh = dh;
+
+    if (mProxy != nullptr) {
+//         mProxy->DrawImageDataWithoutStringCmd(p->tw,
+//                                               p->th,
+//                                               (unsigned char *)(p->Bitmap),
+//                                               p->sx,
+//                                               p->sy,
+//                                               p->sw,
+//                                               p->sh,
+//                                               p->dx,
+//                                               p->dy,
+//                                               p->dw,
+//                                               p->dh);
+
+        // above can't work, don't know why, so use addBitmapQueue below
+
+        LOG_D("start to drawImageData,tw=%d,th=%d,sx=%d,sy=%d,sw=%d,sh=%d,dx=%d,dy=%d,dw=%d,dh=%d\n", tw, th, sx, sy,
+              sw, sh, dx, dy, dw, dh);
+
+        pthread_mutex_lock(&m_mutex);
+        mProxy->addBitmapQueue(p);
+        m_bindtexture = true;
+        pthread_cond_signal(&m_cond);
+        pthread_mutex_unlock(&m_mutex);
+
+        gcanvas::waitUtilTimeout(&m_SyncSem, GCANVAS_TIMEOUT);
+
+        LOG_D("finish wait in drawImageData.");
+    } else {
+        free(pixels);
+        delete p;
+        LOG_D("the proxy is null when drawImageData.");
+    }
+}
+
+void GRenderer::bindTexture(OH_PixelmapNative *pixelmap, int id, int target, int level, int internalformat, int format,
+                            int type) {
+    LOG_D("bindTexture start");
+    uint32_t width = 0;
+    uint32_t height = 0;
+    int32_t pixelFormat = PIXEL_FORMAT_UNKNOWN;
+
+    OH_Pixelmap_ImageInfo *imageInfo = nullptr;
+    Image_ErrorCode errorCode = OH_PixelmapImageInfo_Create(&imageInfo);
+    if (errorCode != IMAGE_SUCCESS) {
+        LOG_E("GetImageSize Create ImageInfo Failed: %{public}d", errorCode);
+        return;
+    }
+    errorCode = OH_PixelmapNative_GetImageInfo(pixelmap, imageInfo);
+    if (errorCode != IMAGE_SUCCESS) {
+        LOG_E("GetImageSize Get ImageInfo Failed: %{public}d", errorCode);
+        OH_PixelmapImageInfo_Release(imageInfo);
+        return;
+    }
+
+    OH_PixelmapImageInfo_GetWidth(imageInfo, &width);
+    OH_PixelmapImageInfo_GetHeight(imageInfo, &height);
+    Image_ErrorCode errorcode = OH_PixelmapImageInfo_GetPixelFormat(imageInfo, &pixelFormat);
+    if (errorcode != IMAGE_SUCCESS) {
+        OH_PixelmapImageInfo_Release(imageInfo);
+        LOG_E("OH_PixelmapImageInfo_GetPixelFormat errorcode:%d", errorcode);
+        return;
+    }
+
+    OH_PixelmapImageInfo_Release(imageInfo);
+
+    if (width <= 0 || height <= 0 ||
+        (pixelFormat != PIXEL_FORMAT_RGB_565 && pixelFormat != PIXEL_FORMAT_RGBA_8888 &&
+         pixelFormat != PIXEL_FORMAT_BGRA_8888)) {
+        LOG_E("the bitmap format no support width:%d;height:%d,format:%d", width, height, pixelFormat);
+        return;
+    }
+    size_t channel = 4;
+    if (pixelFormat == PIXEL_FORMAT_RGB_565) {
+        LOG_D("the bitmap is rgb format.");
+        format = GL_RGB;
+        channel = 3;
+        internalformat = GL_RGB;
+    } else if (pixelFormat == PIXEL_FORMAT_RGBA_8888 || pixelFormat == PIXEL_FORMAT_BGRA_8888) {
+        channel = 4;
+        format = GL_RGBA;
+        internalformat = GL_RGBA;
+    } else {
+        LOG_E("the bitmap format not support,format:%d",pixelFormat);
+        return;
+    }
+
+    size_t bufferSize = width * height * channel;
+    uint8_t *pixels = (uint8_t *)malloc(bufferSize);
+    auto code = OH_PixelmapNative_ReadPixels(pixelmap, pixels, &bufferSize);
+    if (code != IMAGE_SUCCESS) {
+        free(pixels);
+        LOG_E("bindTexture get Pixels failed code:%d", code);
+        return;
+    }
+    bindTexture(pixels, static_cast<int>(width), static_cast<int>(height), id, target, level,
+                internalformat, format, type);
+    free(pixels);
+    LOG_D("bindTexture end");
+}
+
+void GRenderer::bindTexture(const void *pixels, int width, int height, int id, int target, int level,
+                            int internalformat, int format, int type) {
+    if (pixels == nullptr || width <= 0 || height <= 0) {
+        LOG_E("bindTexture invalid raw pixels or size");
+        return;
+    }
+
+    size_t channels = format == GL_RGB ? 3U : 4U;
+    size_t bufferSize = static_cast<size_t>(width) * static_cast<size_t>(height) * channels;
+    uint8_t *pixelsCopy = static_cast<uint8_t *>(malloc(bufferSize));
+    if (pixelsCopy == nullptr) {
+        LOG_E("bindTexture cannot allocate %zu bytes", bufferSize);
+        return;
+    }
+    memcpy(pixelsCopy, pixels, bufferSize);
+
+    struct BitmapCmd *p = new struct BitmapCmd();
+    p->Bitmap = pixelsCopy;
+    p->width = width;
+    p->height = height;
+    p->target = target;
+    p->level = level;
+    p->interformat = internalformat;
+    p->format = format;
+    p->type = type;
+    p->id = id;
+
+    if (mProxy != nullptr) {
+        LOG_D("queue raw texture,width=%d,height=%d,target=%d,level=%d,internalformat=%d,format=%d,type=%d\n",
+              width, height, target, level, internalformat, format, type);
+        pthread_mutex_lock(&m_mutex);
+        mProxy->addBitmapQueue(p);
+        m_bindtexture = true;
+        pthread_cond_signal(&m_cond);
+        pthread_mutex_unlock(&m_mutex);
+        gcanvas::waitUtilTimeout(&m_SyncSem, GCANVAS_TIMEOUT);
+    } else {
+        free(pixelsCopy);
+        delete p;
+        LOG_D("the proxy is null when binding raw texture.");
+    }
+}
+
+void GRenderer::surfaceDestroy() {
+    LOG_D("surface destroy request in grenderer.");
+    pthread_mutex_lock(&m_mutex);
+    m_requestSurfaceDestroy = true;
+    pthread_cond_signal(&m_cond);
+    pthread_mutex_unlock(&m_mutex);
+}
+
+bool GRenderer::sendEvent() {
+    bool ret = m_sendEvent;
+    m_sendEvent = false;
+    return ret;
+}
+
+void GRenderer::setDevicePixelRatio(const float ratio) {
+    pthread_mutex_lock(&m_mutex);
+    this->m_device_pixel_ratio = ratio;
+    if (mProxy) {
+        mProxy->SetDevicePixelRatio(ratio);
+    }
+    pthread_mutex_unlock(&m_mutex);
+}
+
+void GRenderer::setEnableFboMsaa(bool enabled) {
+    pthread_mutex_lock(&m_mutex);
+    bool changed = m_enableFboMsaa != enabled;
+    m_enableFboMsaa = enabled;
+    // InitFBO consumes this value while the GL thread handles a viewport
+    // change. Merely changing GCanvas2DContextHarmony::mEnableFboMsaa after
+    // initialization leaves the existing FBO untouched, so recreate the 2D
+    // context when the prop changes at runtime.
+    if (changed && m_initialized && m_context_type == 0) {
+        m_viewportchanged = true;
+        pthread_cond_signal(&m_cond);
+    }
+    pthread_mutex_unlock(&m_mutex);
+}