Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1badb712 authored by Jack Palevich's avatar Jack Palevich Committed by The Android Open Source Project
Browse files

Automated import from //branches/master/...@142578,142578

parent 15ba2780

core/jni/com_google_android_gles_jni_EGLImpl.cpp

+193 −112
Original line number Diff line number Diff line
@@ -103,8 +103,42 @@ static void nativeClassInit(JNIEnv *_env, jclass eglImplClass) 
    gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "I");

}



jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display,

static const jint gNull_attrib_base[] = {EGL_NONE};



static bool validAttribList(JNIEnv *_env, jintArray attrib_list) {

    if (attrib_list == NULL) {

        return true;

    }

    jsize len = _env->GetArrayLength(attrib_list);

    if (len < 1) {

        return false;

    }

    jint item = 0;

    _env->GetIntArrayRegion(attrib_list, len-1, 1, &item);

    return item == EGL_NONE;

}



static jint* beginNativeAttribList(JNIEnv *_env, jintArray attrib_list) {

    if (attrib_list != NULL) {

        return (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);

    } else {

        return(jint*) gNull_attrib_base;

    }

}



static void endNativeAttributeList(JNIEnv *_env, jintArray attrib_list, jint* attrib_base) {

    if (attrib_list != NULL) {

        _env->ReleasePrimitiveArrayCritical(attrib_list, attrib_base, JNI_ABORT);

    }

}



static jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display,

        jintArray major_minor) {

    if (display == NULL || (major_minor != NULL &&

            _env->GetArrayLength(major_minor) < 2)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }



    EGLDisplay dpy = getDisplay(_env, display);

    jboolean success = eglInitialize(dpy, NULL, NULL);
@@ -121,14 +155,15 @@ jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display, 
    return success;

}



jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display,

static jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display,

        jobject context, jint attribute, jintArray value) {

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext ctx = getContext(_env, context);

    if (value == NULL) {

        doThrow(_env, "java/lang/NullPointerException");

    if (display == NULL || context == NULL || value == NULL

        || _env->GetArrayLength(value) < 1) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext ctx = getContext(_env, context);

    jboolean success = JNI_FALSE;

    int len = _env->GetArrayLength(value);

    if (len) {
@@ -139,14 +174,16 @@ jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display, 
    return success;

}



jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display,

static jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display,

        jobject surface, jint attribute, jintArray value) {

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext sur = getSurface(_env, surface);

    if (value == NULL) {

        doThrow(_env, "java/lang/NullPointerException");

    if (display == NULL || surface == NULL || value == NULL

        || _env->GetArrayLength(value) < 1) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext sur = getSurface(_env, surface);



    jboolean success = JNI_FALSE;

    int len = _env->GetArrayLength(value);

    if (len) {
@@ -157,22 +194,33 @@ jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display, 
    return success;

}



jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display,

static jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display,

        jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) {

    EGLDisplay dpy = getDisplay(_env, display);

    if (attrib_list==NULL || configs==NULL || num_config==NULL) {

        doThrow(_env, "java/lang/NullPointerException");

    if (display == NULL

        || !validAttribList(_env, attrib_list)

        || (configs != NULL && _env->GetArrayLength(configs) < config_size)

        || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    jboolean success = JNI_FALSE;

    jint* attrib_base  = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);

    jint* num_base     = (jint *)_env->GetPrimitiveArrayCritical(num_config, (jboolean *)0);



    if (configs == NULL) {

        config_size = 0;

    }

    EGLConfig nativeConfigs[config_size];

    success = eglChooseConfig(dpy, attrib_base, nativeConfigs, config_size, num_base);

    int num = num_base[0];

    _env->ReleasePrimitiveArrayCritical(num_config, num_base, JNI_ABORT);

    _env->ReleasePrimitiveArrayCritical(attrib_list, attrib_base, JNI_ABORT);

    if (success) {



    int num = 0;

    jint* attrib_base = beginNativeAttribList(_env, attrib_list);

    success = eglChooseConfig(dpy, attrib_base, configs ? nativeConfigs : 0, config_size, &num);

    endNativeAttributeList(_env, attrib_list, attrib_base);



    if (num_config != NULL) {

        _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);

    }



    if (success && configs!=NULL) {

        for (int i=0 ; i<num ; i++) {

            jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]);

            _env->SetObjectArrayElement(configs, i, obj);
@@ -181,36 +229,34 @@ jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display, 
    return success;

}



jint jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display,

static jint jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display,

        jobject config, jobject share_context, jintArray attrib_list) {

    if (display == NULL || config == NULL || share_context == NULL

        || !validAttribList(_env, attrib_list)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLConfig  cnf = getConfig(_env, config);

    EGLContext shr = getContext(_env, share_context);

    jint* base = 0;

    if (attrib_list) {

        // XXX: if array is malformed, we should return an NPE instead of segfault

        base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);

    }

    jint* base = beginNativeAttribList(_env, attrib_list);

    EGLContext ctx = eglCreateContext(dpy, cnf, shr, base);

    if (attrib_list) {

        _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);

    }

    endNativeAttributeList(_env, attrib_list, base);

    return (jint)ctx;

}



jint jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display,

static jint jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display,

        jobject config, jintArray attrib_list) {

    if (display == NULL || config == NULL

        || !validAttribList(_env, attrib_list)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLConfig  cnf = getConfig(_env, config);

    jint* base = 0;

    if (attrib_list) {

        // XXX: if array is malformed, we should return an NPE instead of segfault

        base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);

    }

    jint* base = beginNativeAttribList(_env, attrib_list);

    EGLSurface sur = eglCreatePbufferSurface(dpy, cnf, base);

    if (attrib_list) {

        _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);

    }

    endNativeAttributeList(_env, attrib_list, base);

    return (jint)sur;

}
@@ -225,10 +271,15 @@ static PixelFormat convertPixelFormat(SkBitmap::Config format) 
    }

}



void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur,

static void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur,

        jobject display, jobject config, jobject native_pixmap,

        jintArray attrib_list)

{

    if (display == NULL || config == NULL || native_pixmap == NULL

        || !validAttribList(_env, attrib_list)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLConfig  cnf = getConfig(_env, config);

    jint* base = 0;
@@ -238,7 +289,7 @@ void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur, 
                    gBitmap_NativeBitmapFieldID);

    SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0;

    if (ref == NULL) {

        doThrow(_env, "java/lang/NullPointerException", "Bitmap has no PixelRef");

        doThrow(_env, "java/lang/IllegalArgumentException", "Bitmap has no PixelRef");

        return;

    }
@@ -253,14 +304,9 @@ void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur, 
    pixmap.format = convertPixelFormat(nativeBitmap->config());

    pixmap.data   = (uint8_t*)ref->pixels();



    if (attrib_list) {

        // XXX: if array is malformed, we should return an NPE instead of segfault

        base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);

    }

    base = beginNativeAttribList(_env, attrib_list);

    EGLSurface sur = eglCreatePixmapSurface(dpy, cnf, &pixmap, base);

    if (attrib_list) {

        _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);

    }

    endNativeAttributeList(_env, attrib_list, base);



    if (sur != EGL_NO_SURFACE) {

        _env->SetIntField(out_sur, gSurface_EGLSurfaceFieldID, (int)sur);
@@ -271,14 +317,19 @@ void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur, 
    }

}



jint jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display,

static jint jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display,

        jobject config, jobject native_window, jintArray attrib_list) {

    if (display == NULL || config == NULL

        || !validAttribList(_env, attrib_list)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext cnf = getConfig(_env, config);

    Surface* window = 0;

    if (native_window == NULL) {

not_valid_surface:

        doThrow(_env, "java/lang/NullPointerException",

        doThrow(_env, "java/lang/IllegalArgumentException",

                "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface");

        return 0;

    }
@@ -286,50 +337,48 @@ not_valid_surface: 
    if (window == NULL)

        goto not_valid_surface;



    jint* base = 0;

    if (attrib_list) {

        // XXX: if array is malformed, we should return an NPE instead of segfault

        base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);

    }

    jint* base = beginNativeAttribList(_env, attrib_list);

    EGLSurface sur = eglCreateWindowSurface(dpy, cnf, new EGLNativeWindowSurface(window), base);

    if (attrib_list) {

        _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);

    }

    endNativeAttributeList(_env, attrib_list, base);

    return (jint)sur;

}



jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display,

static jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display,

        jobject config, jint attribute, jintArray value) {

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext cnf = getConfig(_env, config);

    if (value == NULL) {

        doThrow(_env, "java/lang/NullPointerException");

    if (display == NULL || config == NULL

        || (value == NULL || _env->GetArrayLength(value) < 1)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext cnf = getConfig(_env, config);

    jboolean success = JNI_FALSE;

    int len = _env->GetArrayLength(value);

    if (len) {

        jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0);

        success = eglGetConfigAttrib(dpy, cnf, attribute, base);

        _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT);

    jint localValue;

    success = eglGetConfigAttrib(dpy, cnf, attribute, &localValue);

    if (success) {

        _env->SetIntArrayRegion(value, 0, 1, &localValue);

    }

    return success;

}



jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display,

static jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display,

        jobjectArray configs, jint config_size, jintArray num_config) {

    if (display == NULL || (configs != NULL && _env->GetArrayLength(configs) < config_size)

        || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    jboolean success = JNI_FALSE;

    if (num_config == NULL) {

        doThrow(_env, "java/lang/NullPointerException");

        return JNI_FALSE;

    if (configs == NULL) {

        config_size = 0;

    }

    jint* num_base = (jint *)_env->GetPrimitiveArrayCritical(num_config, (jboolean *)0);

    EGLConfig nativeConfigs[config_size];

    success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, num_base);

    int num = num_base[0];

    _env->ReleasePrimitiveArrayCritical(num_config, num_base, JNI_ABORT);



    int num;

    success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, &num);

    if (num_config != NULL) {

        _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);

    }

    if (success && configs) {

        for (int i=0 ; i<num ; i++) {

            jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]);
@@ -339,30 +388,42 @@ jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display, 
    return success;

}



jint jni_eglGetError(JNIEnv *_env, jobject _this) {

static jint jni_eglGetError(JNIEnv *_env, jobject _this) {

    EGLint error = eglGetError();

    return error;

}



jint jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) {

static jint jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) {

    return (jint)eglGetCurrentContext();

}



jint jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) {

static jint jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) {

    return (jint)eglGetCurrentDisplay();

}



jint jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) {

static jint jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) {

    if (!(readdraw == EGL_READ) || (readdraw == EGL_DRAW)) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return 0;

    }

    return (jint)eglGetCurrentSurface(readdraw);

}



jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) {

static jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) {

    if (display == NULL || context == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLContext ctx = getContext(_env, context);

    return eglDestroyContext(dpy, ctx);

}



jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) {

static jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) {

    if (display == NULL || surface == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLSurface sur = getSurface(_env, surface);
@@ -377,11 +438,15 @@ jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, job 
    return eglDestroySurface(dpy, sur);

}



jint jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {

static jint jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {

    return (jint)eglGetDisplay(EGL_DEFAULT_DISPLAY);

}



jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) {

static jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) {

    if (display == NULL || draw == NULL || read == NULL || context == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLSurface sdr = getSurface(_env, draw);

    EGLSurface srd = getSurface(_env, read);
@@ -389,34 +454,50 @@ jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobjec 
    return eglMakeCurrent(dpy, sdr, srd, ctx);

}



jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) {

static jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) {

    if (display == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return NULL;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    const char* chars = eglQueryString(dpy, name);

    return _env->NewStringUTF(chars);

}



jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) {

static jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) {

    if (display == NULL || surface == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    EGLSurface sur = getSurface(_env, surface);

    return eglSwapBuffers(dpy, sur);

}



jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) {

static jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) {

    if (display == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    EGLDisplay dpy = getDisplay(_env, display);

    return eglTerminate(dpy);

}



jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display,

static jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display,

        jobject surface, jobject native_pixmap) {

    // TODO: implement me

    if (display == NULL || surface == NULL || native_pixmap == NULL) {

        doThrow(_env, "java/lang/IllegalArgumentException");

        return JNI_FALSE;

    }

    // TODO: Implement this

    return JNI_FALSE;

}



jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) {

static jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) {

    return eglWaitGL();

}



jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) {

static jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) {

    return eglWaitNative(engine);

}

opengl/libagl/egl.cpp

+18 −6
Original line number Diff line number Diff line
@@ -1056,7 +1056,11 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 
    if (egl_display_t::is_valid(dpy) == EGL_FALSE)

        return setError(EGL_BAD_DISPLAY, EGL_FALSE);

    

    if (ggl_unlikely(configs==0 || attrib_list==0)) {

    if (ggl_unlikely(num_config==0)) {

        return setError(EGL_BAD_PARAMETER, EGL_FALSE);

    }



    if (ggl_unlikely(attrib_list==0)) {

        *num_config = 0;

        return EGL_TRUE;

    }
@@ -1102,6 +1106,7 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 
    // return the configurations found

    int n=0;

    if (possibleMatch) {

        if (configs) {

            for (int i=0 ; config_size && i<numConfigs ; i++) {

                if (possibleMatch & (1<<i)) {

                    *configs++ = (EGLConfig)i;
@@ -1109,6 +1114,13 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 
                    n++;

                }

            }

        } else {

            for (int i=0 ; i<numConfigs ; i++) {

                if (possibleMatch & (1<<i)) {

                    n++;

                }

            }

        }

    }

    *num_config = n;

     return EGL_TRUE;

opengl/libs/EGL/egl.cpp

+20 −15
Original line number Diff line number Diff line
@@ -725,9 +725,8 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 
    egl_display_t const * const dp = get_display(dpy);

    if (!dp) return setError(EGL_BAD_DISPLAY, EGL_FALSE);



    if (configs == 0) {

        *num_config = 0;

        return EGL_TRUE;

    if (num_config==0) {

        return setError(EGL_BAD_PARAMETER, EGL_FALSE);

    }



    EGLint n;
@@ -784,7 +783,9 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 
            if (res && n>0) {

                // n has to be 0 or 1, by construction, and we already know

                // which config it will return (since there can be only one).

                if (configs) {

                    configs[0] = MAKE_CONFIG(i, index);

                }

                *num_config = 1;

            }

        }
@@ -798,19 +799,23 @@ EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list, 
        if (cnx->dso) {

            if (cnx->hooks->egl.eglChooseConfig(

                    dp->dpys[i], attrib_list, configs, config_size, &n)) {

                if (configs) {

                    // now we need to convert these client EGLConfig to our

                    // internal EGLConfig format. This is done in O(n log n).

                    for (int j=0 ; j<n ; j++) {

                        int index = binarySearch<EGLConfig>(

                                dp->configs[i], 0, dp->numConfigs[i]-1, configs[j]);

                        if (index >= 0) {

                            if (configs) {

                                configs[j] = MAKE_CONFIG(i, index);

                            }

                        } else {

                            return setError(EGL_BAD_CONFIG, EGL_FALSE);

                        }

                    }

                    configs += n;

                    config_size -= n;

                }

                *num_config += n;

                res = EGL_TRUE;

            }