opengl/tests/copybits/copybits.cpp

// Test software OpenGL hardware accelleration using copybits.

#define LOG_TAG "copybits_test"

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>

#include <ui/PixelFormat.h>

#include <cutils/log.h>
#include <cutils/native_handle.h>

#include <utils/Atomic.h>

#include <private/ui/SharedState.h>

#include <hardware/gralloc.h>
#include <hardware/hardware.h>

#define EGL_EGLEXT_PROTOTYPES
#define GL_GLEXT_PROTOTYPES

#include <EGL/egl.h>
#include <EGL/eglext.h>

#include <GLES/gl.h>
#include <GLES/glext.h>

extern "C" EGLNativeWindowType android_createDisplaySurface(void);

using namespace android;

EGLDisplay eglDisplay;
EGLSurface eglSurface;
EGLContext eglContext;
GLuint texture;

hw_module_t const* gralloc_module;
alloc_device_t  *sAllocDev;

#define FIXED_ONE 0x10000

int init_gl_surface();
void free_gl_surface();
void init_scene();

int create_physical_texture();
int readTimer();

// ===========================================================================
// Buffer and implementation of android_native_buffer_t
// ===========================================================================

class NativeBuffer;

class Buffer :  public android_native_buffer_t,
                public LightRefBase<Buffer>
{
public:

    // creates w * h buffer
    Buffer(uint32_t w, uint32_t h, PixelFormat format, int usage);

    // return status
    status_t initCheck() const;


    uint32_t getWidth() const           { return mWidth; }
    uint32_t getHeight() const          { return mHeight; }
    uint32_t getStride() const          { return mStride; }
    uint32_t getUsage() const           { return mUsage; }
    PixelFormat getPixelFormat() const  { return mFormat; }
    buffer_handle_t getHandle() const   { return mBufferHandle; }

    android_native_buffer_t* getNativeBuffer() const;

    void setPixel(int x, int y, int r, int g, int b, int a);

private:
    friend class LightRefBase<Buffer>;
    Buffer(const Buffer& rhs);
    ~Buffer();
    Buffer& operator = (const Buffer& rhs);
    const Buffer& operator = (const Buffer& rhs) const;

    status_t initSize(uint32_t w, uint32_t h);

    static void incRef(android_native_base_t* buffer);
    static void decRef(android_native_base_t* buffer);
    static int getHandlePriv(android_native_buffer_t const * buffer,
            buffer_handle_t* handle);

    buffer_handle_t         mBufferHandle;
    ssize_t                 mInitCheck;

    uint32_t                mWidth;
    uint32_t                mHeight;
    uint32_t                mStride;
    uint32_t                mVStride;
    PixelFormat             mFormat;
    void*                   mData;
    uint32_t                mUsage;
};

Buffer::Buffer(uint32_t w, uint32_t h, PixelFormat format, int usage)
    : mBufferHandle(0), mInitCheck(NO_INIT),
    mWidth(0), mHeight(0), mStride(0), mVStride(0), mFormat(format), mData(0),
    mUsage(usage)
{
    common.magic = ANDROID_NATIVE_BUFFER_MAGIC;
    common.version = sizeof(android_native_buffer_t);
    common.incRef = incRef;
    common.decRef = decRef;
    android_native_buffer_t::getHandle = getHandlePriv;
    if (w>0 && h>0) {
        mInitCheck = initSize(w, h);
    }
}

Buffer::~Buffer()
{
    if (mBufferHandle) {

        gralloc_module_t* mod = (gralloc_module_t*)sAllocDev->common.module;
        mod->unmap(mod, mBufferHandle);

        sAllocDev->free(sAllocDev, mBufferHandle);
    }
}

void Buffer::incRef(android_native_base_t* buffer) {
    Buffer* self = static_cast<Buffer*>(
            reinterpret_cast<android_native_buffer_t *>(buffer));
    self->incStrong(self);
}

void Buffer::decRef(android_native_base_t* buffer) {
    Buffer* self = static_cast<Buffer*>(
            reinterpret_cast<android_native_buffer_t *>(buffer));
    self->decStrong(self);
}

int Buffer::getHandlePriv(android_native_buffer_t const * buffer,
        buffer_handle_t* handle) {
    Buffer const * self = static_cast<Buffer const *>(buffer);
    *handle = self->getHandle();
    return 0;
}

status_t Buffer::initCheck() const {
    return mInitCheck;
}

android_native_buffer_t* Buffer::getNativeBuffer() const
{
    Buffer* that = const_cast<Buffer*>(this);
    that->android_native_buffer_t::width = mWidth;
    that->android_native_buffer_t::height = mHeight;
    that->android_native_buffer_t::stride = mStride;
    that->android_native_buffer_t::format = mFormat;
    that->android_native_buffer_t::usage = mUsage;
    that->android_native_buffer_t::bits = mData;
    return static_cast<android_native_buffer_t*>(that);
}

status_t Buffer::initSize(uint32_t w, uint32_t h)
{
    status_t err = NO_ERROR;

    int32_t stride;
    err = sAllocDev->alloc(sAllocDev, w, h, mFormat, mUsage, &mBufferHandle, &stride);

    if (err == NO_ERROR) {
        void* addr = 0;
        gralloc_module_t* mod = (gralloc_module_t*)sAllocDev->common.module;
        err = mod->map(mod, mBufferHandle, &addr);
        if (err == NO_ERROR) {
            mData = addr;
            mWidth  = w;
            mHeight = h;
            mStride = stride;
            mVStride = 0;
        }
    }

    return err;
}

void Buffer::setPixel(int x, int y, int r, int g, int b, int a) {
    if (x < 0 || (unsigned int) x >= mWidth
            || y < 0 || (unsigned int) y >= mHeight) {
        // clipped
        return;
    }
    int index = mStride * y + x;
    switch (mFormat) {
    case HAL_PIXEL_FORMAT_RGB_565: {
            unsigned short val = (unsigned short) (
                    ((0x1f & (r >> 3)) << 11)
                    | ((0x3f & (g >> 2)) << 5)
                    | (0x1f & (b >> 3)));
            ((unsigned short*) mData)[index]= val;
        }
        break;
    case HAL_PIXEL_FORMAT_RGBA_8888: { // ABGR
        unsigned int val = (unsigned int)
            (((a & 0xff) << 24)
                    | ((b & 0xff) << 16)
                    | ((g & 0xff) << 8)
                    | (r & 0xff));
            ((unsigned int*) mData)[index] = val;
        }
        break;
    default:
        // Unsupported pixel format
        break;
    }
}


static void gluLookAt(float eyeX, float eyeY, float eyeZ,
        float centerX, float centerY, float centerZ, float upX, float upY,
        float upZ)
{
    // See the OpenGL GLUT documentation for gluLookAt for a description
    // of the algorithm. We implement it in a straightforward way:

    float fx = centerX - eyeX;
    float fy = centerY - eyeY;
    float fz = centerZ - eyeZ;

    // Normalize f
    float rlf = 1.0f / sqrtf(fx*fx + fy*fy + fz*fz);
    fx *= rlf;
    fy *= rlf;
    fz *= rlf;

    // Normalize up
    float rlup = 1.0f / sqrtf(upX*upX + upY*upY + upZ*upZ);
    upX *= rlup;
    upY *= rlup;
    upZ *= rlup;

    // compute s = f x up (x means "cross product")

    float sx = fy * upZ - fz * upY;
    float sy = fz * upX - fx * upZ;
    float sz = fx * upY - fy * upX;

    // compute u = s x f
    float ux = sy * fz - sz * fy;
    float uy = sz * fx - sx * fz;
    float uz = sx * fy - sy * fx;

    float m[16] ;
    m[0] = sx;
    m[1] = ux;
    m[2] = -fx;
    m[3] = 0.0f;

    m[4] = sy;
    m[5] = uy;
    m[6] = -fy;
    m[7] = 0.0f;

    m[8] = sz;
    m[9] = uz;
    m[10] = -fz;
    m[11] = 0.0f;

    m[12] = 0.0f;
    m[13] = 0.0f;
    m[14] = 0.0f;
    m[15] = 1.0f;

    glMultMatrixf(m);
    glTranslatef(-eyeX, -eyeY, -eyeZ);
}

int init_gralloc() {
    int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &gralloc_module);
    LOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID);

    if (err == 0) {
        gralloc_open(gralloc_module, &sAllocDev);
    }
    return err;
}

int init_gl_surface(void)
{
    EGLint numConfigs = 1;
    EGLConfig myConfig = {0};
    EGLint attrib[] =
    {
            EGL_DEPTH_SIZE,     16,
            EGL_NONE
    };

    printf("init_gl_surface\n");
    if ( (eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY )
    {
        printf("eglGetDisplay failed\n");
        return 0;
    }

    if ( eglInitialize(eglDisplay, NULL, NULL) != EGL_TRUE )
    {
        printf("eglInitialize failed\n");
        return 0;
    }

    if ( eglChooseConfig(eglDisplay, attrib, &myConfig, 1, &numConfigs) != EGL_TRUE )
    {
        printf("eglChooseConfig failed\n");
        return 0;
    }

    if ( (eglSurface = eglCreateWindowSurface(eglDisplay, myConfig,
            android_createDisplaySurface(), 0)) == EGL_NO_SURFACE )
    {
        printf("eglCreateWindowSurface failed\n");
        return 0;
    }

    if ( (eglContext = eglCreateContext(eglDisplay, myConfig, 0, 0)) == EGL_NO_CONTEXT )
    {
        printf("eglCreateContext failed\n");
        return 0;
    }

    if ( eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) != EGL_TRUE )
    {
        printf("eglMakeCurrent failed\n");
        return 0;
    }

    return 1;
}

void free_gl_surface(void)
{
    if (eglDisplay != EGL_NO_DISPLAY)
    {
        eglMakeCurrent( EGL_NO_DISPLAY, EGL_NO_SURFACE,
                EGL_NO_SURFACE, EGL_NO_CONTEXT );
        eglDestroyContext( eglDisplay, eglContext );
        eglDestroySurface( eglDisplay, eglSurface );
        eglTerminate( eglDisplay );
        eglDisplay = EGL_NO_DISPLAY;
    }
}

void init_scene(void)
{
    glDisable(GL_DITHER);
    glEnable(GL_CULL_FACE);
    float ratio = 320.0f /  480.0f;
    glViewport(0, 0, 320, 480);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustumf(-ratio, ratio, -1, 1, 1, 10);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();
    gluLookAt(
            0, 0, 3,  // eye
            0, 0, 0,  // center
            0, 1, 0); // up

    glEnable(GL_TEXTURE_2D);
}

// #define USE_ALPHA_COLOR

#define USE_GL_REPLACE
// #define USE_GL_MODULATE

// #define USE_BLEND

#define USE_565
// #define USE_8888

// #define USE_NEAREST
#define USE_LINEAR

#define USE_SCALE

void setSmoothGradient(Buffer* bufferObject) {
    int pixels = bufferObject->getHeight() * bufferObject->getWidth();
    int step = 0;
    for (unsigned int y = 0; y < bufferObject->getHeight(); y++) {
        for(unsigned int x = 0; x < bufferObject->getWidth() ; x++) {
            int grey = step * 255 / pixels;
            bufferObject->setPixel(x, y, grey, grey, grey, 255);
            ++step;
        }
    }
}

void setSmoothAlphaGradient(Buffer* bufferObject) {
    int pixels = bufferObject->getHeight() * bufferObject->getWidth();
    int step = 0;
    for (unsigned int y = 0; y < bufferObject->getHeight(); y++) {
        for(unsigned int x = 0; x < bufferObject->getWidth() ; x++) {
            int grey = step * 255 / pixels;
            bufferObject->setPixel(x, y, 255, 255, 255, grey);
            ++step;
        }
    }
}

void setOrientedCheckerboard(Buffer* bufferObject) {
    bufferObject->setPixel(0, 0, 0, 0, 0, 255);
    for(unsigned int x = 1; x < bufferObject->getWidth() ; x++) {
        bufferObject->setPixel(x, 0, 0, 255, 0, 255);
    }
    for (unsigned int y = 1; y < bufferObject->getHeight(); y++) {
        for(unsigned int x = 0; x < bufferObject->getWidth() ; x++) {
            if ((x ^ y ) & 1) {
                bufferObject->setPixel(x, y, 255, 255, 255, 255);
            } else {
                bufferObject->setPixel(x, y, 255, 0, 0, 255);
            }
        }
    }
}

int create_physical_texture(unsigned int w, unsigned int h)
{

#ifdef USE_565
    PixelFormat format = HAL_PIXEL_FORMAT_RGB_565;
#else
    PixelFormat format = HAL_PIXEL_FORMAT_RGBA_8888;
#endif
    int usage = GRALLOC_USAGE_SW_READ_OFTEN |
        GRALLOC_USAGE_SW_WRITE_OFTEN |
        GRALLOC_USAGE_HW_TEXTURE |
        GRALLOC_USAGE_HW_2D; /* This is the key to allocating the texture in pmem. */
    int32_t stride;
    buffer_handle_t handle;

    // Allocate the hardware buffer
    Buffer* bufferObject = new Buffer(w, h, format, usage);

    android_native_buffer_t* buffer = bufferObject->getNativeBuffer();

    buffer->common.incRef(&buffer->common);

    // create the new EGLImageKHR
    EGLint attrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_NONE };
    EGLDisplay dpy = eglGetCurrentDisplay();
    EGLImageKHR image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
            (EGLClientBuffer)buffer, attrs);
    if (image == EGL_NO_IMAGE_KHR) {
        printf("Could not create an image %d\n", eglGetError());
        return -1;
    }

    if (buffer->bits == NULL) {
        printf("No bits allocated for image.\n");
        return -2;
    }

    setOrientedCheckerboard(bufferObject);
    // setSmoothGradient(bufferObject);
    // setSmoothAlphaGradient(bufferObject);

    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
#ifdef USE_LINEAR
    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
#elif defined(USE_NEAREST)
    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
#endif

#ifdef USE_GL_REPLACE
    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#elif defined(USE_GL_MODULATE)
    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
#endif

#ifdef USE_ALPHA_COLOR
    glColor4f(1.0f, 1.0f, 1.0f, 0.4f);
#else
    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
#endif

#ifdef USE_BLEND
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
    return 0;
}

static const int SCALE_COUNT = 12;

int scale(int base, int factor) {
    static const float kTable[SCALE_COUNT] = {
            0.1f, 0.25f, 0.5f, 0.75f, 1.0f,
            1.5f, 2.0f, 2.5f, 3.0f, 3.5f, 4.0f, 5.0f
    };
    return base * kTable[factor];
}

class Timer {
    struct timeval  first;
    double elapsedSeconds;

public:
    Timer() {}
    void start() {
        gettimeofday(&first, NULL);
    }

    void stop() {
        struct timeval  second,
                        elapsed;
        gettimeofday(&second, NULL);

        if (first.tv_usec > second.tv_usec) {
           second.tv_usec += 1000000;
           second.tv_sec--;
        }

        elapsedSeconds = (second.tv_sec  - first.tv_sec) +
            (second.tv_usec - first.tv_usec) / 1000000.0;
    }

    double getElapsedSeconds() {
        return elapsedSeconds;
    }

    double getElapsedMs() {
        return elapsedSeconds* 1000.0f;
    }
};

int testTime()
{
    static const int WIDTH = 320;
    static const int HEIGHT = 480;
    static const int SCALE = 8;

    if (create_physical_texture(WIDTH, HEIGHT) != 0) {
        return -1;
    }
    // Need to do a dummy eglSwapBuffers first. Don't know why.
    glClearColor(0.4, 1.0, 0.4, 0.4);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    eglSwapBuffers(eglDisplay, eglSurface);

    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

#if defined(USE_SCALE)
    static const int scaleOffset = 0;
#else
    static const int scaleOffset = 1;
#endif
    printf("ms\n");
    for(int j = 0; j < SCALE; j++) {
        int w = WIDTH >> (j + scaleOffset);
        int h = HEIGHT >> j;
        int cropRect[4] = {0,h,w,-h}; // Left bottom width height. Width and Height can be neg to flip.
        glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, cropRect);
        Timer timer;
        timer.start();

        int copyCount = 1000;
        for (int i = 0; i < copyCount; i++) {
            glDrawTexiOES(0, 0, 0, w, h);
        }

        timer.stop();
        printf("%g\n", timer.getElapsedMs() / copyCount);
    }

    eglSwapBuffers(eglDisplay, eglSurface);
    return 0;
}

int testStretch()
{
    static const int WIDTH = 8;
    static const int HEIGHT = 8;

    if (create_physical_texture(WIDTH, HEIGHT) != 0) {
        return -1;
    }
    // Need to do a dummy eglSwapBuffers first. Don't know why.
    glClearColor(0.4, 1.0, 0.4, 0.4);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    eglSwapBuffers(eglDisplay, eglSurface);

    int cropRect[4] = {0,HEIGHT,WIDTH,-HEIGHT}; // Left bottom width height. Width and Height can be neg to flip.
    glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, cropRect);

    for(int frame = 0; frame < 2; frame++) {
        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
        int baseX = 10;
        for (int x = 0; x < SCALE_COUNT; x++) {
            int baseY = 10;
            int width = scale(WIDTH, x);
            for (int y = 0; y < SCALE_COUNT; y++) {
                int height = scale(HEIGHT, y);
                glDrawTexxOES(baseX << 16, baseY << 16, 0, width << 16, height << 16);
                baseY += height + 10;
            }
            baseX += width + 10;
        }

        eglSwapBuffers(eglDisplay, eglSurface);
    }
    return 0;
}

int testRot90()
{
    static const int WIDTH = 8;
    static const int HEIGHT = 8;

    if (create_physical_texture(WIDTH, HEIGHT) != 0) {
        return -1;
    }

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrthof(0, 320, 480, 0, 0, 1);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    // Need to do a dummy eglSwapBuffers first. Don't know why.
    glClearColor(0.4, 0.4, 0.4, 0.4);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    eglSwapBuffers(eglDisplay, eglSurface);

    glEnable(GL_TEXTURE_2D);
    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glColor4x(0x10000, 0x10000, 0x10000, 0x10000);
    glDisable(GL_BLEND);
    glShadeModel(GL_FLAT);
    glDisable(GL_DITHER);
    glDisable(GL_CULL_FACE);

    for(int frame = 0; frame < 2; frame++) {
        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
        int baseX = 10;
        for (int x = 0; x < SCALE_COUNT; x++) {
            int baseY = 10;
            int width = scale(WIDTH, x);
            for (int y = 0; y < SCALE_COUNT; y++) {
                int height = scale(HEIGHT, y);

                // Code copied from SurfaceFlinger LayerBase.cpp

                const GLfixed texCoords[4][2] = {
                        { 0,        0 },
                        { 0,        0x10000 },
                        { 0x10000,  0x10000 },
                        { 0x10000,  0 }
                };

                GLfixed fx = baseX << 16;
                GLfixed fy = baseY << 16;
                GLfixed fw = width << 16;
                GLfixed fh = height << 16;

                /*
                 * Vertex pattern:
                 *    (2)--(3)
                 *     |\   |
                 *     | \  |
                 *     |  \ |
                 *     |   \|
                 *    (1)--(0)
                 *
                 */

                const GLfixed vertices[4][2] = {
                        {fx + fw, fy},
                        {fx,      fy},
                        {fx,      fy + fh},
                        {fx + fw, fy + fh}
                };

                static const bool rotate90 = true;

                glMatrixMode(GL_TEXTURE);
                glLoadIdentity();

                glEnableClientState(GL_VERTEX_ARRAY);
                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                glVertexPointer(2, GL_FIXED, 0, vertices);
                glTexCoordPointer(2, GL_FIXED, 0, texCoords);

                LOGW("testRot90 %d, %d %d, %d", baseX, baseY, width, height);
                glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

                baseY += height + 10;
            }
            baseX += width + 10;
        }

        eglSwapBuffers(eglDisplay, eglSurface);
    }
    return 0;
}

int main(int argc, char **argv)
{

    int q;
    int start, end;

    if (init_gralloc()) {
        printf("gralloc initialization failed - exiting\n");
        return 0;
    }

    printf("Initializing EGL...\n");

    if(!init_gl_surface())
    {
        printf("GL initialisation failed - exiting\n");
        return 0;
    }

    init_scene();

    printf("Start test...\n");
    // testTime();
    // testStretch();
    testRot90();
    free_gl_surface();

    return 0;
}