refactor EGL source code

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= 	       \

	EGL/egl_tls.cpp        \

	EGL/egl_display.cpp    \

	EGL/egl_object.cpp     \

	EGL/egl.cpp 	       \

	EGL/eglApi.cpp 	       \

	EGL/trace.cpp              \

	EGL/getProcAddress.cpp.arm \

	EGL/hooks.cpp 	       \

/* 

 ** Copyright 2007, The Android Open Source Project

 **

 ** Licensed under the Apache License, Version 2.0 (the "License"); 

 ** you may not use this file except in compliance with the License. 

 ** You may obtain a copy of the License at 

 **

 **     http://www.apache.org/licenses/LICENSE-2.0 

 **

 ** Unless required by applicable law or agreed to in writing, software 

 ** distributed under the License is distributed on an "AS IS" BASIS, 

 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

 ** See the License for the specific language governing permissions and 

 ** limitations under the License.

 */

#include "egl_display.h"

#include "egl_object.h"

#include "egl_tls.h"

#include "egl_impl.h"

#include "Loader.h"

// ----------------------------------------------------------------------------

namespace android {

// ----------------------------------------------------------------------------

extern void initEglTraceLevel();

extern void setGLHooksThreadSpecific(gl_hooks_t const *value);

static int cmp_configs(const void* a, const void *b) {

    const egl_config_t& c0 = *(egl_config_t const *)a;

    const egl_config_t& c1 = *(egl_config_t const *)b;

    return c0<c1 ? -1 : (c1<c0 ? 1 : 0);

}

// ----------------------------------------------------------------------------

egl_display_t egl_display_t::sDisplay[NUM_DISPLAYS];

egl_display_t::egl_display_t() :

    magic('_dpy'), numTotalConfigs(0), configs(0), refs(0) {

}

egl_display_t::~egl_display_t() {

    magic = 0;

}

egl_display_t* egl_display_t::get(EGLDisplay dpy) {

    uintptr_t index = uintptr_t(dpy)-1U;

    return (index >= NUM_DISPLAYS) ? NULL : &sDisplay[index];

}

void egl_display_t::addObject(egl_object_t* object) {

    Mutex::Autolock _l(lock);

    objects.add(object);

}

bool egl_display_t::getObject(egl_object_t* object) {

    Mutex::Autolock _l(lock);

    if (objects.indexOf(object) >= 0) {

        object->incRef();

        return true;

    }

    return false;

}

bool egl_display_t::removeObject(egl_object_t* object) {

    Mutex::Autolock _l(lock);

    if (object->decRef() == 1) {

        objects.remove(object);

        return true;

    }

    return false;

}

EGLDisplay egl_display_t::getFromNativeDisplay(EGLNativeDisplayType disp) {

    if (uintptr_t(disp) >= NUM_DISPLAYS)

        return NULL;

    return sDisplay[uintptr_t(disp)].getDisplay(disp);

}

EGLDisplay egl_display_t::getDisplay(EGLNativeDisplayType display) {

    Mutex::Autolock _l(lock);

    // get our driver loader

    Loader& loader(Loader::getInstance());

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

        egl_connection_t* const cnx = &gEGLImpl[i];

        if (cnx->dso && disp[i].dpy == EGL_NO_DISPLAY) {

            EGLDisplay dpy = cnx->egl.eglGetDisplay(display);

            disp[i].dpy = dpy;

            if (dpy == EGL_NO_DISPLAY) {

                loader.close(cnx->dso);

                cnx->dso = NULL;

            }

        }

    }

    return EGLDisplay(uintptr_t(display) + 1U);

}

EGLBoolean egl_display_t::initialize(EGLint *major, EGLint *minor) {

    Mutex::Autolock _l(lock);

    if (refs > 0) {

        if (major != NULL)

            *major = VERSION_MAJOR;

        if (minor != NULL)

            *minor = VERSION_MINOR;

        refs++;

        return EGL_TRUE;

    }

#if EGL_TRACE

    // Called both at early_init time and at this time. (Early_init is pre-zygote, so

    // the information from that call may be stale.)

    initEglTraceLevel();

#endif

    setGLHooksThreadSpecific(&gHooksNoContext);

    // initialize each EGL and

    // build our own extension string first, based on the extension we know

    // and the extension supported by our client implementation

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

        egl_connection_t* const cnx = &gEGLImpl[i];

        cnx->major = -1;

        cnx->minor = -1;

        if (!cnx->dso)

            continue;

#if defined(ADRENO130)

#warning "Adreno-130 eglInitialize() workaround"

        /*

         * The ADRENO 130 driver returns a different EGLDisplay each time

         * eglGetDisplay() is called, but also makes the EGLDisplay invalid

         * after eglTerminate() has been called, so that eglInitialize()

         * cannot be called again. Therefore, we need to make sure to call

         * eglGetDisplay() before calling eglInitialize();

         */

        if (i == IMPL_HARDWARE) {

            disp[i].dpy =

            cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);

        }

#endif

        EGLDisplay idpy = disp[i].dpy;

        if (cnx->egl.eglInitialize(idpy, &cnx->major, &cnx->minor)) {

            //LOGD("initialized %d dpy=%p, ver=%d.%d, cnx=%p",

            //        i, idpy, cnx->major, cnx->minor, cnx);

            // display is now initialized

            disp[i].state = egl_display_t::INITIALIZED;

            // get the query-strings for this display for each implementation

            disp[i].queryString.vendor = cnx->egl.eglQueryString(idpy,

                    EGL_VENDOR);

            disp[i].queryString.version = cnx->egl.eglQueryString(idpy,

                    EGL_VERSION);

            disp[i].queryString.extensions = cnx->egl.eglQueryString(idpy,

                    EGL_EXTENSIONS);

            disp[i].queryString.clientApi = cnx->egl.eglQueryString(idpy,

                    EGL_CLIENT_APIS);

        } else {

            LOGW("%d: eglInitialize(%p) failed (%s)", i, idpy,

                    egl_tls_t::egl_strerror(cnx->egl.eglGetError()));

        }

    }

    EGLBoolean res = EGL_FALSE;

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

        egl_connection_t* const cnx = &gEGLImpl[i];

        if (cnx->dso && cnx->major >= 0 && cnx->minor >= 0) {

            EGLint n;

            if (cnx->egl.eglGetConfigs(disp[i].dpy, 0, 0, &n)) {

                disp[i].config = (EGLConfig*) malloc(sizeof(EGLConfig) * n);

                if (disp[i].config) {

                    if (cnx->egl.eglGetConfigs(disp[i].dpy, disp[i].config, n,

                            &disp[i].numConfigs)) {

                        numTotalConfigs += n;

                        res = EGL_TRUE;

                    }

                }

            }

        }

    }

    if (res == EGL_TRUE) {

        configs = new egl_config_t[numTotalConfigs];

        for (int i = 0, k = 0; i < IMPL_NUM_IMPLEMENTATIONS; i++) {

            egl_connection_t* const cnx = &gEGLImpl[i];

            if (cnx->dso && cnx->major >= 0 && cnx->minor >= 0) {

                for (int j = 0; j < disp[i].numConfigs; j++) {

                    configs[k].impl = i;

                    configs[k].config = disp[i].config[j];

                    configs[k].configId = k + 1; // CONFIG_ID start at 1

                    // store the implementation's CONFIG_ID

                    cnx->egl.eglGetConfigAttrib(disp[i].dpy, disp[i].config[j],

                            EGL_CONFIG_ID, &configs[k].implConfigId);

                    k++;

                }

            }

        }

        // sort our configurations so we can do binary-searches

        qsort(configs, numTotalConfigs, sizeof(egl_config_t), cmp_configs);

        refs++;

        if (major != NULL)

            *major = VERSION_MAJOR;

        if (minor != NULL)

            *minor = VERSION_MINOR;

        return EGL_TRUE;

    }

    return setError(EGL_NOT_INITIALIZED, EGL_FALSE);

}

EGLBoolean egl_display_t::terminate() {

    Mutex::Autolock _l(lock);

    if (refs == 0) {

        return setError(EGL_NOT_INITIALIZED, EGL_FALSE);

    }

    // this is specific to Android, display termination is ref-counted.

    if (refs > 1) {

        refs--;

        return EGL_TRUE;

    }

    EGLBoolean res = EGL_FALSE;

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

        egl_connection_t* const cnx = &gEGLImpl[i];

        if (cnx->dso && disp[i].state == egl_display_t::INITIALIZED) {

            if (cnx->egl.eglTerminate(disp[i].dpy) == EGL_FALSE) {

                LOGW("%d: eglTerminate(%p) failed (%s)", i, disp[i].dpy,

                        egl_tls_t::egl_strerror(cnx->egl.eglGetError()));

            }

            // REVISIT: it's unclear what to do if eglTerminate() fails

            free(disp[i].config);

            disp[i].numConfigs = 0;

            disp[i].config = 0;

            disp[i].state = egl_display_t::TERMINATED;

            res = EGL_TRUE;

        }

    }

    // TODO: all egl_object_t should be marked for termination

    refs--;

    numTotalConfigs = 0;

    delete[] configs;

    return res;

}

// ----------------------------------------------------------------------------

}; // namespace android

// ----------------------------------------------------------------------------

/* 

 ** Copyright 2007, The Android Open Source Project

 **

 ** Licensed under the Apache License, Version 2.0 (the "License"); 

 ** you may not use this file except in compliance with the License. 

 ** You may obtain a copy of the License at 

 **

 **     http://www.apache.org/licenses/LICENSE-2.0 

 **

 ** Unless required by applicable law or agreed to in writing, software 

 ** distributed under the License is distributed on an "AS IS" BASIS, 

 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

 ** See the License for the specific language governing permissions and 

 ** limitations under the License.

 */

#ifndef ANDROID_EGL_DISPLAY_H

#define ANDROID_EGL_DISPLAY_H

#include <ctype.h>

#include <stdint.h>

#include <stdlib.h>

#include <EGL/egl.h>

#include <EGL/eglext.h>

#include <GLES/gl.h>

#include <GLES/glext.h>

#include <utils/SortedVector.h>

#include <utils/threads.h>

#include "hooks.h"

// ----------------------------------------------------------------------------

namespace android {

// ----------------------------------------------------------------------------

class egl_object_t;

class egl_connection_t;

// ----------------------------------------------------------------------------

struct egl_config_t {

    egl_config_t() {}

    egl_config_t(int impl, EGLConfig config)

        : impl(impl), config(config), configId(0), implConfigId(0) { }

    int         impl;           // the implementation this config is for

    EGLConfig   config;         // the implementation's EGLConfig

    EGLint      configId;       // our CONFIG_ID

    EGLint      implConfigId;   // the implementation's CONFIG_ID

    inline bool operator < (const egl_config_t& rhs) const {

        if (impl < rhs.impl) return true;

        if (impl > rhs.impl) return false;

        return config < rhs.config;

    }

};

// ----------------------------------------------------------------------------

class egl_display_t {

    static egl_display_t sDisplay[NUM_DISPLAYS];

    EGLDisplay getDisplay(EGLNativeDisplayType display);

public:

    enum {

        NOT_INITIALIZED = 0,

        INITIALIZED     = 1,

        TERMINATED      = 2

    };

    egl_display_t();

    ~egl_display_t();

    EGLBoolean initialize(EGLint *major, EGLint *minor);

    EGLBoolean terminate();

    // add object to this display's list

    void addObject(egl_object_t* object);

    // remove object from this display's list if it has no reference.

    // returns true if object was removed.

    bool removeObject(egl_object_t* object);

    // add reference to this object. returns true if this is a valid object.

    bool getObject(egl_object_t* object);

    static egl_display_t* get(EGLDisplay dpy);

    static EGLDisplay getFromNativeDisplay(EGLNativeDisplayType disp);

    inline bool isReady() const { return (refs > 0); }

    inline bool isValid() const { return magic == '_dpy'; }

    inline bool isAlive() const { return isValid(); }

    struct strings_t {

        char const * vendor;

        char const * version;

        char const * clientApi;

        char const * extensions;

    };

    struct DisplayImpl {

        DisplayImpl() : dpy(EGL_NO_DISPLAY), config(0),

                        state(NOT_INITIALIZED), numConfigs(0) { }

        EGLDisplay  dpy;

        EGLConfig*  config;

        EGLint      state;

        EGLint      numConfigs;

        strings_t   queryString;

    };

private:

    uint32_t        magic;

public:

    DisplayImpl     disp[IMPL_NUM_IMPLEMENTATIONS];

    EGLint          numTotalConfigs;

    egl_config_t*   configs;

private:

    uint32_t        refs;

    Mutex           lock;

    SortedVector<egl_object_t*> objects;

};

// ----------------------------------------------------------------------------

inline egl_display_t* get_display(EGLDisplay dpy) {

    return egl_display_t::get(dpy);

}

// ----------------------------------------------------------------------------

egl_display_t* validate_display(EGLDisplay dpy);

egl_connection_t* validate_display_config(EGLDisplay dpy,

        EGLConfig config, egl_display_t const*& dp);

EGLBoolean validate_display_context(EGLDisplay dpy, EGLContext ctx);

EGLBoolean validate_display_surface(EGLDisplay dpy, EGLSurface surface);

// ----------------------------------------------------------------------------

}; // namespace android

// ----------------------------------------------------------------------------

#endif // ANDROID_EGL_DISPLAY_H