path: root/ri/src/linux/riEGLOS.cpp

/*------------------------------------------------------------------------
 *
 * EGL 1.3
 * -------
 *
 * Copyright (c) 2007 The Khronos Group Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and /or associated documentation files
 * (the "Materials "), to deal in the Materials without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Materials,
 * and to permit persons to whom the Materials are furnished to do so,
 * subject to the following conditions: 
 *
 * The above copyright notice and this permission notice shall be included 
 * in all copies or substantial portions of the Materials. 
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
 * THE USE OR OTHER DEALINGS IN THE MATERIALS.
 *
 *//**
 * \file
 * \brief	Generic OS EGL functionality (not thread safe, no window rendering)
 * \note
  *//*-------------------------------------------------------------------*/

#include <stdio.h>
#include <unistd.h>   
#include <stdio.h>   
#include <fcntl.h>   
#include <stdlib.h>
#include <linux/fb.h>   
#include <sys/mman.h>   
 #include <sys/ioctl.h>

#include "egl.h"
#include "riImage.h"
#include <pthread.h>
#include <sys/errno.h>
#include <GLES2/gl2.h>
#include "esUtil.h"

#ifdef MINIEGL_DEBUG
#define DBG(M, ...) printf("[MINIEGL][%s]:" M "\n", __func__, ##__VA_ARGS__)
#else
#define DBG(M, ...)
#endif

#define MINIEGL_ERROR
#ifdef SHIM_ERROR
#define _ERR(M, ...) fprintf(stderr, "[MINIEGL][%s] %d: " M "\n", __func__, __LINE__, ##__VA_ARGS__)
#else
#define _ERR(M, ...)
#endif

typedef struct
{
// Handle to a program object
GLuint programObject;

} UserData;

namespace OpenVGRI
{

/*-------------------------------------------------------------------*//*!
* \brief	
* \param	
* \return	
* \note		
*//*-------------------------------------------------------------------*/

void* OSGetCurrentThreadID(void)
{
	return (void*)pthread_self();   //TODO this is not safe
}

/*-------------------------------------------------------------------*//*!
* \brief	
* \param	
* \return	
* \note		
*//*-------------------------------------------------------------------*/
static pthread_mutex_t mutex;
static int mutexRefCount = 0;
static bool mutexInitialized = false;
//acquired mutex cannot be deinited
//
void OSDeinitMutex(void)
{
	RI_ASSERT(mutexInitialized);
	RI_ASSERT(mutexRefCount == 0);

    int ret = pthread_mutex_destroy(&mutex);
    RI_ASSERT(ret != EINVAL);   //assert that the mutex has been initialized
    RI_ASSERT(ret != EAGAIN);   //assert that the maximum number of recursive locks hasn't been exceeded
    RI_ASSERT(!ret);    //check that there aren't other errors
    RI_UNREF(ret);
    
}
void OSAcquireMutex(void)
{
    if(!mutexInitialized)
    {
        int ret;
        pthread_mutexattr_t attr;
        ret = pthread_mutexattr_init(&attr);    //initially not locked
        RI_ASSERT(!ret);    //check that there aren't any errors
        ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);    //count the number of recursive locks
        RI_ASSERT(!ret);    //check that there aren't any errors
        ret = pthread_mutex_init(&mutex, &attr);
        pthread_mutexattr_destroy(&attr);
        RI_ASSERT(!ret);    //check that there aren't more errors
        RI_UNREF(ret);
        mutexInitialized = true;
    }
    int ret = pthread_mutex_lock(&mutex);
    RI_ASSERT(ret != EINVAL);   //assert that the mutex has been initialized
    RI_ASSERT(ret != EAGAIN);   //assert that the maximum number of recursive locks hasn't been exceeded
    RI_ASSERT(ret != EDEADLK);  //recursive mutexes shouldn't return this
    RI_ASSERT(!ret);    //check that there aren't other errors
    RI_UNREF(ret);
    mutexRefCount++;
}

void OSReleaseMutex(void)
{
    RI_ASSERT(mutexInitialized);
    mutexRefCount--;
    RI_ASSERT(mutexRefCount >= 0);
    int ret = pthread_mutex_unlock(&mutex);
    RI_ASSERT(ret != EPERM);    //assert that the current thread owns the mutex
    RI_ASSERT(!ret);    //check that there aren't more errors
    RI_UNREF(ret);
}

/*-------------------------------------------------------------------*//*!
* \brief    
* \param    
* \return   
* \note     
*//*-------------------------------------------------------------------*/

static bool isBigEndian()
{
    static const RIuint32 v = 0x12345678u;
    const RIuint8* p = (const RIuint8*)&v;
    RI_ASSERT (*p == (RIuint8)0x12u || *p == (RIuint8)0x78u);
    return (*p == (RIuint8)(0x12)) ? true : false;
}

/*-------------------------------------------------------------------*//*!
* \brief	
* \param	
* \return	
* \note		
*//*-------------------------------------------------------------------*/

#define FB_DEVICE   "/dev/fb0"

struct OSWindowContext
{
	ESContext *esContext;
	GLuint programObject;
	GLuint vertexShader;
	GLuint fragmentShader;
    EGLNativeWindowType window;
    unsigned int*       tmp;
    int                 tmpWidth;
    int                 tmpHeight;
/*    int                 fbfd;
    unsigned long       screensize;
    unsigned long       windowsize;
    char*               fbp;
    unsigned int*       tmp;
    int                 tmpWidth;
    int                 tmpHeight;
    struct              fb_var_screeninfo vinfo;   
    struct              fb_fix_screeninfo finfo; */
    
};

// Uniform index.
enum {
UNIFORM_VIDEOFRAME,
UNIFORM_INPUTCOLOR,
UNIFORM_THRESHOLD,
NUM_UNIFORMS
};
GLint uniforms[NUM_UNIFORMS];

// Attribute index.
enum {
ATTRIB_VERTEX,
ATTRIB_TEXTUREPOSITON,
NUM_ATTRIBUTES
};

static const GLfloat squareVertices[] = {
  -1.0f, -1.0f,
   1.0f, -1.0f,
  -1.0f,  1.0f,
   1.0f,  1.0f,
};

static const GLfloat textureVertices[] = {
    1.0f, 1.0f,
    1.0f, 0.0f,
    0.0f,  1.0f,
    0.0f,  0.0f,
};

GLuint LoadShader ( GLenum type, const char *shaderSrc )
{
   GLuint shader;
   GLint compiled;

   // Create the shader object
   shader = glCreateShader ( type );

   if ( shader == 0 )
    return 0;

   // Load the shader source
   glShaderSource ( shader, 1,(const GLchar * const *) shaderSrc, NULL );

   // Compile the shader
   glCompileShader ( shader );

   // Check the compile status
   glGetShaderiv ( shader, GL_COMPILE_STATUS, &compiled );

   if ( !compiled )
   {
      GLint infoLen = 0;

      glGetShaderiv ( shader, GL_INFO_LOG_LENGTH, &infoLen );

      if ( infoLen > 1 )
      {
         char* infoLog =(char *) malloc (sizeof(char) * infoLen );

         glGetShaderInfoLog ( shader, infoLen, NULL, infoLog );
         esLogMessage ( "Error compiling shader:\n%s\n", infoLog );

         free ( infoLog );
      }

      glDeleteShader ( shader );
      return 0;
   }

   return shader;

}



int OSGLESinit (void* v) {
OSWindowContext * ctx = (OSWindowContext *)v;
GLbyte vShaderStr[] = 
"attribute vec4 position; \n"
"attribute vec4 inputTextureCoordinate; \n"
" \n"
"varying vec2 textureCoordinate; \n"
" \n"
"void main() \n"
"{\n"
"    gl_Position = position;\n"
"    textureCoordinate = inputTextureCoordinate.xy;\n"
"}\n"
" \n";

GLbyte fShaderStr[] =
"varying highp vec2 textureCoordinate; \n"
" \n"
"uniform sampler2D openvgFrame; \n"
" \n"
"void main() \n"
"{ \n"
"    gl_FragColor = texture2D(openvgFrame, textureCoordinate); \n"
"} \n";

GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;

	// Load the vertex/fragment shaders
	vertexShader = LoadShader(GL_VERTEX_SHADER,(const char *) vShaderStr );
	fragmentShader = LoadShader(GL_FRAGMENT_SHADER, (const char *)fShaderStr );

    programObject = glCreateProgram( );

	if ( programObject == 0 )
		return 0;

	glAttachShader(programObject, vertexShader );
	glAttachShader(programObject, fragmentShader );

    glBindAttribLocation(programObject, ATTRIB_VERTEX, "position");
    glBindAttribLocation(programObject, ATTRIB_TEXTUREPOSITON, "inputTextureCoordinate");

	glLinkProgram(programObject);

	glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );

   if ( !linked ) 
   {   
      GLint infoLen = 0;

      glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );

      if ( infoLen > 1 )
      {
         char* infoLog =(char *) malloc (sizeof(char) * infoLen );

         glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
         esLogMessage ( "Error linking program:\n%s\n", infoLog );

         free ( infoLog );
      }

      glDeleteProgram ( programObject );
      return GL_FALSE;
   }


	glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );

	ctx->programObject = programObject;
	ctx->vertexShader = vertexShader;
	ctx->fragmentShader = fragmentShader;
}


void* OSCreateWindowContext(EGLNativeWindowType window)
{
    try
    {
        OSWindowContext* ctx = RI_NEW(OSWindowContext, ());
        ctx->esContext = RI_NEW(ESContext, ());
        ctx->window = window;

        ctx->tmp = NULL;
        ctx->tmpWidth = window->width;
        ctx->tmpHeight = window->height;
/*
		OSGLESinit(ctx);

        // Open the framebuffer fb for reading and writing   
        ctx->fbfd = open("/dev/fb0", O_RDWR);   
        if (!ctx->fbfd) {   
            _ERR("Error: cannot open framebuffer device.\n");   
            return NULL;
        }   
        DBG("The framebuffer device was opened successfully.\n");


        // Get fixed screen information   
        if (ioctl(ctx->fbfd, FBIOGET_FSCREENINFO, &ctx->finfo)) {   
            _ERR("Error reading fixed information.\n");   
            return NULL;  
        }

        // Get variable screen information   
        if (ioctl(ctx->fbfd, FBIOGET_VSCREENINFO, &ctx->vinfo)) {   
            _ERR("Error reading variable information.\n");   
            return NULL;  
        }   

        // Figure out the size of the screen in bytes   
        ctx->screensize = ctx->vinfo.xres * ctx->vinfo.yres * ctx->vinfo.bits_per_pixel / 8;  

        // Figure out the size of the screen in bytes   
        ctx->windowsize = window->width * window->height * ctx->vinfo.bits_per_pixel / 8; 
   
        DBG("%dx%d, %dbpp, screen size = %d\n",  ctx->vinfo.xres, 
                                                ctx->vinfo.yres, 
                                                ctx->vinfo.bits_per_pixel, 
                                                ctx->screensize );  

        DBG("%dx%d, %dbpp, window size = %d\n", window->width, 
                                                window->height, 
                                                ctx->vinfo.bits_per_pixel, 
                                                ctx->windowsize ); 

        // Map the device to memory   
        ctx->fbp = (char *)mmap(0, ctx->screensize, PROT_READ | PROT_WRITE, MAP_SHARED,   
                                ctx->fbfd, 0);   
        if ((int)ctx->fbp == -1) {   
            _ERR("Error: failed to map framebuffer device to memory.\n");   
            return NULL;  
        }   
        DBG("The framebuffer device was mapped to memory successfully.\n");    
*/

        return ctx;
    }
    catch(std::bad_alloc)
    {
        return NULL;
    }
}

void OSDestroyWindowContext(void* context)
{

    OSWindowContext* ctx = (OSWindowContext*) context;

    if(ctx)
    {
/*        if(ctx->fbp) {
            munmap(ctx->fbp, ctx->screensize);
        }
        close(ctx->fbfd);
        RI_DELETE_ARRAY(ctx->tmp);
        RI_DELETE(ctx); */
    }
}

bool OSIsWindow(const void* context)
{
    OSWindowContext* ctx = (OSWindowContext*)context;
    if(ctx)
    {
        //TODO implement
        return true;
    }
    return false;
}

void OSGetWindowSize(const void* context, int& width, int& height)
{
    OSWindowContext* ctx = (OSWindowContext*)context;
    if(ctx)
    {
        width = ctx->esContext->width;
        height = ctx->esContext->height;
    }
    else
    {
        width = 0;
        height = 0;
    }
}

void OSBlitToWindow(void* context, const Drawable* drawable)
{
    OSWindowContext* ctx = (OSWindowContext*)context;
    VGImageFormat f;
    unsigned int w = drawable->getWidth();
    unsigned int h = drawable->getHeight();
    unsigned int y = 0;
    unsigned int    *fb_loc;
    unsigned int    *ctx_loc;
	GLuint videoFrameTexture;
	GLuint FrameBufferVGTexture;

    if(ctx)
    {
        printf("drawable: %dx%d\n", drawable->getWidth(), drawable->getHeight());  

 /*       int w = drawable->getWidth();
        int h = drawable->getHeight();

        printf("drawable: %dx%d\n", drawable->getWidth(), drawable->getHeight());  
*/
        if(!ctx->tmp || ctx->tmpWidth != w || ctx->tmpHeight != h)
        {
            RI_DELETE_ARRAY(ctx->tmp);
            ctx->tmp = NULL;
            try
            {
                ctx->tmp = RI_NEW_ARRAY(unsigned int, w*h); //throws bad_alloc
                ctx->tmpWidth = w;
                ctx->tmpHeight = h;
            }
            catch(std::bad_alloc)
            {
                _ERR("context temp memory alloc fail.\n"); 
                
            }
        }

        if(ctx->tmp)
        {
        f = VG_sARGB_8888;
        vgReadPixels(ctx->tmp, w*sizeof(unsigned int), f, 0, 0, w, h);


	glGenTextures(1, &videoFrameTexture);
	glBindTexture(GL_TEXTURE_2D, videoFrameTexture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// This is necessary for non-power-of-two textures
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);




/*		glViewport(0, 0, w, h);
		glDisable(GL_DEPTH_TEST);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity(); */


		glActiveTexture(GL_TEXTURE0);
		glGenTextures(2, &FrameBufferVGTexture);
		glBindTexture(GL_TEXTURE_2D, FrameBufferVGTexture);

		glUniform1i(uniforms[UNIFORM_VIDEOFRAME], 0);   

		glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, squareVertices);
		glEnableVertexAttribArray(ATTRIB_VERTEX);
		glVertexAttribPointer(ATTRIB_TEXTUREPOSITON, 2, GL_FLOAT, 0, 0, textureVertices);
		glEnableVertexAttribArray(ATTRIB_TEXTUREPOSITON);

		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);






        //NOTE: we assume here that the display is always in sRGB color space

//            f = VG_sXBGR_8888;
//     --->             f = VG_sARGB_8888;
//            if(isBigEndian())
//               f = VG_sRGBX_8888;
        
        vgReadPixels(ctx->tmp, w*sizeof(unsigned int), f, 0, 0, w, h);
//		glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, ctx->tmp);
        }

		eglSwapBuffers(ctx->esContext->eglDisplay, ctx->esContext->eglSurface);

/*
        if(ctx->fbp)
        {

            fb_loc = (unsigned int *)ctx->fbp;
            ctx_loc = ctx->tmp+w*(h-1);
            DBG("==fb_loc: %x, ctx_loc:%x ==", fb_loc, ctx_loc);  
            for( y = 0; y < h; y++){
                fb_loc += ctx->vinfo.xres;
                memcpy(fb_loc, ctx_loc, w*sizeof(unsigned int));
                ctx_loc -= w; 
            }
        }
	*/

	

    }
}

EGLDisplay OSGetDisplay(EGLNativeDisplayType display_id)
{
    RI_UNREF(display_id);
    return (EGLDisplay)1;    //support only a single display
}

}   //namespace OpenVGRI