First steps towards Shader MoComp, not displaying properly yet

diff --git a/GNUmakefile b/GNUmakefile
index 99dc70da4734091da2628de98ba9ed0a9ff8bb69..4e386e1f4253be46392e296e33d51ecb9c4ea33f 100755 (executable)
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -58,7 +58,7 @@ $(info Raspberry pi flags)
 LDFLAGS = -Wall\r
 LIBS = -L/opt/vc/lib -lpthread -lrt -lEGL -lGLESv2 -lopenmaxil -lbcm_host   -lavcodec -lavformat -lavutil\r
 \r
-OBJECTS += main.o threadp.o osdopengl.o surfaceopengl.o ledraspberry.o mtdraspberry.o videovpeogl.o audiovpe.o wjpegsimple.o remotelinux.o glshader.o glosdshader.o glyuv400shader.o glmocoshader.o\r
+OBJECTS += main.o threadp.o osdopengl.o surfaceopengl.o ledraspberry.o mtdraspberry.o videovpeogl.o audiovpe.o wjpegsimple.o remotelinux.o glshader.o glosdshader.o glyuv400shader.o glyuv444shader.o  glmocoshader.o\r
 LIBS+= -ljpeg\r
 CROSSLIBS =\r
 INCLUDES = -DVOMP_PLATTFORM_RASPBERRY   -I/opt/vc/include \r

diff --git a/glmocoshader.cc b/glmocoshader.cc
index 3f29910f24ff6afabe26ce383d888cc345a9f97e..22c0eb2319715594defb07ae41b3d963b9f43eed 100755 (executable)
--- a/glmocoshader.cc
+++ b/glmocoshader.cc
@@ -20,50 +20,142 @@
 #include "glmocoshader.h"\r
 #include "videovpeogl.h"\r
 \r
+#define BLOCK_TEXTURE_WIDTH 2048\r
+#define BLOCK_TEXTURE_HEIGHT 1024\r
+#define BLOCK_SIZE 64\r
+#define BLOCK_PER_ROW 32\r
+\r
 const GLchar moco_vertex_shader[] =\r
-               "attribute vec4 vec_pos;\n"\r
-               "attribute vec2 tex_coord;\n"\r
-               "varying vec2 out_texCoord;\n"\r
+               "attribute vec4 block_pos;\n"\r
+               "attribute vec2 block_edge;\n"\r
+               "attribute vec4 block_types;\n"\r
+               "attribute vec2 index;\n"\r
+               "attribute float cbp;\n"\r
+               "uniform vec2 pict_scale;\n"\r
+       //      "attribute vec2 tex_coord;\n"\r
+               "varying vec4 out_yblockpos_x;\n"\r
+               "varying vec4 out_yblockpos_y;\n"\r
+               "varying vec4 out_uvblockpos_xy;\n"\r
+               "varying vec2 out_block_edge;\n"\r
+\r
+               "const float one=1.0;\n"\r
+               "const float c1024=1024.0;\n"\r
+               "const float c32=32.0;\n"\r
+\r
+\r
+               "const float c65536=65536.;\n"\r
+\r
+\r
+\r
+               "const vec4  y_cbp=vec4(1.0,2.0,4.0,8.0);\n"\r
+               "const vec2  uv_cbp=vec2(16.0,32.0);\n"\r
                "void main()\n"\r
                "{\n"\r
-               " gl_Position=vec_pos;\n"\r
-               " out_texCoord=tex_coord;\n"\r
+               // calculate cbp\r
+               "  vec4 cbp_vec=vec4(cbp,cbp,cbp,cbp);\n"\r
+               "  vec4 fmod_cbp_y=mod(cbp_vec,y_cbp);\n"\r
+               "  vec2 fmod_cbp_uv=mod(cbp_vec.xy,uv_cbp);\n"\r
+               "  fmod_cbp_y=sign(vec4(fmod_cbp_y.yzw,fmod_cbp_uv.x)-fmod_cbp_y);\n"\r
+               "  fmod_cbp_uv=sign(vec2(fmod_cbp_uv.y,cbp)-fmod_cbp_uv);\n"\r
+               // resulting vector should indicate with block is present\r
+               // now transform it to a sum (TODO vectorize this)\r
+               "  vec4 fmod_cbp_y2=fmod_cbp_y;\n"\r
+               "  vec2 fmod_cbp_uv2=fmod_cbp_uv;\n"\r
+               "  fmod_cbp_y2.y+=fmod_cbp_y2.x;\n"\r
+               "  fmod_cbp_y2.z+=fmod_cbp_y2.y;\n"\r
+               "  fmod_cbp_y2.w+=fmod_cbp_y2.z;\n"\r
+               "  fmod_cbp_uv2.x+=fmod_cbp_y2.w;\n"\r
+               "  fmod_cbp_uv2.y+=fmod_cbp_uv2.x;\n"\r
+\r
+               // now calculate their position inside the short array\r
+               "  float m_index=index.x+index.y*c65536;\n" //Not Endian save\r
+               "  fmod_cbp_y2+=m_index;\n" //shift to the blocks\r
+               "  fmod_cbp_uv2+=m_index;\n"\r
+               "  out_yblockpos_x=mod(fmod_cbp_y2,c32);\n"\r
+               "  out_uvblockpos_xy.xy=mod(fmod_cbp_uv2,c32);\n"\r
+               "  out_yblockpos_y=floor((fmod_cbp_y2)/c32);\n"\r
+               "  out_uvblockpos_xy.zw=floor((fmod_cbp_uv2)/c32);\n"\r
+\r
+               //Kick out uncoded blocks\r
+               "  out_yblockpos_y-=sign(fmod_cbp_y-one)*c1024;\n"\r
+               "  out_uvblockpos_xy.zw-=sign(fmod_cbp_uv-one)*c1024;\n"\r
+\r
+\r
+               "  out_block_edge=block_edge;\n"\r
+               "  vec4 out_pos=block_pos;\n"\r
+               "  out_pos.xy+=block_edge;\n"\r
+               "  out_pos.xy*=pict_scale;\n"\r
+               "  out_pos.xy-=vec2(one,one);"\r
+               "  out_pos.zw=vec2(one,one);"\r
+               " gl_Position=out_pos;\n"\r
                "}\n";\r
 \r
 const GLchar moco_frag_shader[] =\r
                "precision mediump float;\n"\r
-               "uniform sampler2D textureU;\n"\r
-               "uniform sampler2D textureV;\n"\r
-               "uniform sampler2D textureY;\n"\r
-               "const float uv_corr=0.5;\n"\r
-               "const float y_corr=0.0625;\n"\r
-               "const mat3 yuvtransform= mat3( 1.164 ,0.0  ,1.596   ,\n"\r
-               "                               1.164 ,-0.391,-0.813   ,\n"\r
-               "                               1.164,2.018  , 0.0 );\n"\r
-//             "const mat3 yuvtransform= mat3( 1. ,1.  ,1.   ,\n"\r
-//             "                               0.0 ,-0.3960,2.029   ,\n"\r
-//             "                               1.140,-0.581  , 0.0 );\n"\r
-//             "const mat3 yuvtransform= mat3( 1. ,0  ,0.   ,\n"\r
-//             "                               0.0 ,1.,0.   ,\n"\r
-//             "                               0.,0.  , 1.0 );\n"\r
-//             "const mat3 yuvtransform= mat3( 1. ,1.  ,1.   ,\n"\r
-//             "                               0.0 ,-0.03960,0.2029   ,\n"\r
-//             "                               0.1140,-0.0581  , 0.0 );\n"\r
-               "varying vec2 out_texCoord;\n"\r
+               "uniform sampler2D blocks;\n"\r
+               "varying vec4 out_yblockpos_x;\n"\r
+               "varying vec4 out_yblockpos_y;\n"\r
+               "varying vec4 out_uvblockpos_xy;\n"\r
+               "varying vec2 out_block_edge;\n"\r
+               "const float halfst=0.5;\n"\r
+               "const float ctwo=2.0;\n"\r
+               "const float sieben=7.0;\n"\r
+               "const float acht=8.0;\n"\r
+               "const float s8=1./8.;\n"\r
+               "const float s16=1./16.;\n"\r
+               "const float c1over2047=1./2047.;\n"\r
+               "const float c1over1023=1./1023.;\n"\r
+               "const float c255=255.;\n"\r
+               "const float c65280=65280.;\n"\r
+               "const float c65536=65536.;\n"\r
+               "const float cstep=32767.;\n"\r
+               "\n"\r
+               "float unpack_short(vec2 income) {\n"\r
+               "   float temp=income.y*c65280+income.x*c255;\n"\r
+               "   temp-=step(cstep,temp)*c65536;\n"\r
+               "   return abs(temp/c255);\n" //temporary work around\r
+               "}"\r
+       //      "uniform sampler2D textureV;\n"\r
+       //      "uniform sampler2D textureY;\n"\r
+//             "varying vec2 out_texCoord;\n"\r
                "void main()\n"\r
                "{\n"\r
-               " vec3 help;\n"\r
-               "help.x=texture2D(textureY,out_texCoord).r-y_corr;\n"\r
-               "help.y=texture2D(textureU,out_texCoord).r-uv_corr;\n"\r
-               "help.z=texture2D(textureV,out_texCoord).r-uv_corr;\n" //-uv_corr;\n"\r
-               "  gl_FragColor.rgb=help*yuvtransform;\n"\r
-               " gl_FragColor.a=1.;\n"\r
+               // first figure out the block num for y, first decide between up and down, fix me field\r
+        //non field code\r
+       //      " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"\r
+       //      "                  vec4(out_yblockpos_x.z,out_yblockpos_y.z,out_yblockpos_x.w,out_yblockpos_y.w),step(halfst,out_block_edge.y));\n"\r
+               //field code\r
+               " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"\r
+                               "                  vec4(out_yblockpos_x.z,out_yblockpos_y.z,out_yblockpos_x.w,out_yblockpos_y.w),step(s16,mod(out_block_edge.y,s8)));\n"\r
+\r
+               //decide between left and right\r
+               " vec2 ypos_temp2=mix(ypos_temp1.xy,ypos_temp1.zw,step(halfst,out_block_edge.x));\n"\r
+               //now get the intra 8x8 Block coordinates\r
+               " vec2 ypos_temp3=mod(out_block_edge,halfst)*ctwo;\n"\r
+               " ypos_temp2.x=(ypos_temp3.x*sieben+(ypos_temp3.y*sieben+acht*ypos_temp2.x)*acht)*c1over2047;\n"\r
+               " ypos_temp2.y*=c1over1023;\n"\r
+               " ypos_temp1=texture2D(blocks,ypos_temp2);\n" // now select the right data\r
+               " ypos_temp2=mix(ypos_temp1.rg,ypos_temp1.ba,step(c1over2047,mod(ypos_temp2.x,c1over1023)));\n" //activate this\r
+\r
+               " gl_FragColor.r=unpack_short(ypos_temp2.rg);\n" //signed later TODO\r
+               //" gl_FragColor.r=ypos_temp1.b;\n" //signed later TODO\r
+               " gl_FragColor.g=0.5;\n"\r
+               " gl_FragColor.b=0.5;\n"\r
+               " gl_FragColor.a=1.0;\n"\r
+               //" vec4 blocks=texture2D(blocks,gl_FragCoord.xy/600.);\n"\r
+//             "help.x=texture2D(textureY,out_texCoord).r;\n"\r
+//             "help.y=texture2D(textureU,out_texCoord).r;\n"\r
+//             "help.z=texture2D(textureV,out_texCoord).r;\n" //-uv_corr;\n"\r
+   //  "  gl_FragColor.rgba=blocks;\n"\r
+       //      "  gl_FragColor.rgba=vec4(0.7,0.5,0.5,1.0);\n"\r
+               //"  gl_FragColor.a=1.;\n"\r
                "}\n";\r
 \r
-GLMocoShader::GLMocoShader(): GLShader("GLYuv400Shader")\r
+GLMocoShader::GLMocoShader(): GLShader("GLMocoShader")\r
 {\r
 \r
        frame_buf=0;\r
+       blocks_loc=0;\r
 }\r
 \r
 GLMocoShader::~GLMocoShader()\r
@@ -72,19 +164,32 @@ GLMocoShader::~GLMocoShader()
 }\r
 \r
 int GLMocoShader::init() {\r
+\r
        if (!initShaders(moco_vertex_shader, moco_frag_shader)) {\r
+               Log::getInstance()->log("GLMocoShader", Log::ERR, "init Shaders failed for GLMocoShader");\r
                return 0;\r
        }\r
+       loc_pict_scale = glGetUniformLocation(shad_program, "pict_scale");\r
+       blocks_loc = glGetUniformLocation(shad_program, "blocks");\r
+\r
 //     frame_sampler_locY = glGetUniformLocation(shad_program, "textureY");\r
        // Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locY,glGetError());\r
 //     frame_sampler_locU = glGetUniformLocation(shad_program, "textureU");\r
        //Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locU,glGetError());\r
 //     frame_sampler_locV = glGetUniformLocation(shad_program, "textureV");\r
        glGenFramebuffers(1, &frame_buf);\r
+       //Log::getInstance()->log("GLMocoShader", Log::WARN, "genframe bufmark1 glerror %x",glGetError());\r
        glGenTextures(1, &data_blocks);\r
        glBindTexture(GL_TEXTURE_2D, data_blocks);\r
-       glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 1024, 1024, 0, GL_LUMINANCE_ALPHA,\r
+       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, BLOCK_TEXTURE_WIDTH >>1, BLOCK_TEXTURE_HEIGHT, 0, GL_RGBA,\r
                                GL_UNSIGNED_BYTE, NULL);\r
+       char buffer[BLOCK_TEXTURE_WIDTH*4];\r
+       memset(buffer,0,BLOCK_TEXTURE_WIDTH*4); // the last line is black, simplifies the shader algorithms\r
+\r
+       glTexSubImage2D(GL_TEXTURE_2D,0,0,BLOCK_TEXTURE_HEIGHT-1,\r
+                       1024,1,\r
+                       GL_RGBA,GL_UNSIGNED_BYTE,\r
+                       buffer);\r
 \r
        glGenBuffers(1,&macro_block);\r
        glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
@@ -101,19 +206,24 @@ int GLMocoShader::init() {
        }\r
        GLushort *tri_indices_run=tri_indices;\r
        for (int i=0;i<4096;i++) {\r
-               *tri_indices_run=i+2*4096;  //strip\r
-               tri_indices_run++;\r
                *tri_indices_run=i+0*4096;  //strip\r
                tri_indices_run++;\r
-               *tri_indices_run=i+3*4096;  //strip\r
+               *tri_indices_run=i+2*4096;  //strip\r
                tri_indices_run++;\r
                *tri_indices_run=i+1*4096;  //strip\r
                tri_indices_run++;\r
-               *tri_indices_run=i+1*4096;  //strip\r
+               *tri_indices_run=i+3*4096;  //strip\r
+               tri_indices_run++;\r
+               *tri_indices_run=i+3*4096;  //strip\r
                tri_indices_run++;\r
-               *tri_indices_run=i+1+2*4096;  //strip\r
+               *tri_indices_run=i+1+0*4096;  //strip\r
                tri_indices_run++;\r
        }\r
+\r
+\r
+\r
+\r
+\r
        glBufferData(GL_ELEMENT_ARRAY_BUFFER,4096*6*sizeof(GLushort),tri_indices,GL_STREAM_DRAW);\r
        free(tri_indices);\r
 \r
@@ -129,59 +239,93 @@ int GLMocoShader::init() {
 int GLMocoShader::deinit()\r
 {\r
        glDeleteFramebuffers(1, &frame_buf);\r
-       glDeleteTextures(1, &frame_buf);\r
+       glDeleteTextures(1, &data_blocks);\r
        return deinitShaders();\r
 }\r
 \r
+\r
+\r
 int GLMocoShader::uploadDataBlocks(short* blocks,unsigned int num_blocks, XvMCMacroBlock *m_blocks,unsigned int num_m_blocks)\r
 {\r
-       unsigned int height=(num_blocks+127)/128;\r
+       unsigned int height=(num_blocks)/(BLOCK_PER_ROW);\r
 \r
        glBindTexture(GL_TEXTURE_2D, data_blocks);\r
        glPixelStorei(GL_UNPACK_ALIGNMENT,1);\r
 \r
+\r
+\r
+\r
+       Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark1 glerror %x %d",glGetError(),height);\r
        glTexSubImage2D(GL_TEXTURE_2D,0,0,0,\r
-               1024,height,\r
-               GL_LUMINANCE,GL_UNSIGNED_BYTE,\r
+               BLOCK_TEXTURE_WIDTH>>1,height,\r
+               GL_RGBA,GL_UNSIGNED_BYTE,\r
                blocks);\r
-       //Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
+       Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
+       glTexSubImage2D(GL_TEXTURE_2D,0,0,height+1,\r
+                       (num_blocks%BLOCK_PER_ROW)>>1,1,\r
+                       GL_RGBA,GL_UNSIGNED_BYTE,\r
+                       blocks);\r
+\r
+       Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
+\r
+\r
+\r
+       glBindTexture(GL_TEXTURE_2D, 0);\r
 \r
        valid_macro_blocks=num_m_blocks;\r
        glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
        XvMCMacroBlock *m_blocks_run=m_blocks;\r
        XvMCMacroBlock *m_blocks_end=m_blocks+num_m_blocks;\r
        while (m_blocks_run!=m_blocks_end) {\r
-               m_blocks_run->pad0=0x0000;\r
+               m_blocks_run->pad0=0xFF00;\r
                m_blocks_run++;\r
        }\r
-       glBufferSubData(GL_ARRAY_BUFFER, 0, num_m_blocks * sizeof(XvMCMacroBlock),\r
+       // debug\r
+/*     m_blocks[0].x=0;\r
+       m_blocks[0].y=0;\r
+       m_blocks[3]=m_blocks[2]=m_blocks[1]=m_blocks[0];\r
+       m_blocks[0].pad0=0xFF00;\r
+       m_blocks[1].pad0=0xFFFF;\r
+       m_blocks[2].pad0=0x0000;\r
+       m_blocks[3].pad0=0x00FF;\r
+       m_blocks[1].x=0;\r
+       m_blocks[1].y=0;\r
+       m_blocks[2].x=0;\r
+       m_blocks[2].y=0;\r
+       m_blocks[3].x=0;\r
+       m_blocks[3].y=0;*/\r
+\r
+       glBufferSubData(GL_ARRAY_BUFFER, 0* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),\r
                        m_blocks);\r
 \r
+\r
        m_blocks_run = m_blocks;\r
        m_blocks_end = m_blocks + num_m_blocks;\r
        while (m_blocks_run != m_blocks_end) {\r
-               m_blocks_run->pad0 = 0x00FF;\r
+               m_blocks_run->pad0 = 0xFFFF;\r
                m_blocks_run++;\r
        }\r
-       glBufferSubData(GL_ARRAY_BUFFER, 4096, num_m_blocks * sizeof(XvMCMacroBlock),\r
+       glBufferSubData(GL_ARRAY_BUFFER, 4096* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),\r
                        m_blocks);\r
 \r
+\r
        m_blocks_run = m_blocks;\r
        m_blocks_end = m_blocks + num_m_blocks;\r
        while (m_blocks_run != m_blocks_end) {\r
-               m_blocks_run->pad0 = 0xFF00;\r
+               m_blocks_run->pad0 = 0x0000;\r
                m_blocks_run++;\r
        }\r
-       glBufferSubData(GL_ARRAY_BUFFER, 2 * 4096,\r
+       glBufferSubData(GL_ARRAY_BUFFER, 2 * 4096* sizeof(XvMCMacroBlock),\r
                        num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);\r
 \r
+\r
        m_blocks_run = m_blocks;\r
        m_blocks_end = m_blocks + num_m_blocks;\r
        while (m_blocks_run != m_blocks_end) {\r
-               m_blocks_run->pad0 = 0xFFFF;\r
+               m_blocks_run->pad0 = 0x00FF;\r
                m_blocks_run++;\r
        }\r
-       glBufferSubData(GL_ARRAY_BUFFER, 3 * 4096,\r
+       glBufferSubData(GL_ARRAY_BUFFER, 3 * 4096* sizeof(XvMCMacroBlock),\r
                        num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);\r
 \r
 \r
@@ -193,29 +337,116 @@ int GLMocoShader::uploadDataBlocks(short* blocks,unsigned int num_blocks, XvMCMa
 \r
 }\r
 \r
-int GLMocoShader::doMoCo(VPEOGLFrame *target, VPE_FrameBuf* source)\r
+int GLMocoShader::doMoCo(VPEOGLFrame *target)\r
 {\r
 \r
+//     Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-2 glerror %x %x",glGetError(),frame_buf);\r
+\r
+       //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-1 glerror %x %x",glGetError(),frame_buf);\r
        glBindFramebuffer(GL_FRAMEBUFFER, frame_buf);\r
-       Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1 glerror %x",glGetError());\r
+       Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1 glerror %x %x %x",glGetError(),target->textures[0],target->textures[1]);\r
+\r
+\r
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,\r
                        GL_TEXTURE_2D, target->textures[0], 0);\r
-       Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2 glerror %x",glGetError());\r
+       //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1apres glerror %x",glGetError());\r
+\r
+\r
+\r
+\r
+       //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2 glerror %x",glGetError());\r
+\r
+       //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2a glerror %x",glGetError());\r
 \r
        int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);\r
        if (status == GL_FRAMEBUFFER_COMPLETE) {\r
+               glViewport(0, 0, target->width,target->height);\r
+       //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2b glerror %x",glGetError());\r
+\r
+               XvMCMacroBlock * helperp=NULL;\r
+\r
+               glClearColor(0.0f,0.5f,0.5f,1.f); //this black\r
+               glClear(GL_COLOR_BUFFER_BIT);\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2c glerror %x",glGetError());\r
+\r
                glUseProgram(shad_program);\r
-               Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
+\r
+\r
+               const GLfloat pict_scale[]={  32./((float)target->width),32./((float)target->height)};\r
+\r
+               glUniform2fv(loc_pict_scale,1,(const GLfloat*)&pict_scale);\r
+\r
+\r
+\r
+               glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);\r
+                               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());\r
+               glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 \r
 \r
+\r
+               glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,\r
+                               sizeof(XvMCMacroBlock), NULL);\r
+\r
+               glEnableVertexAttribArray(0);\r
+\r
+               glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));\r
+               glEnableVertexAttribArray(1);\r
+\r
+               glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->macroblock_type));\r
+               glEnableVertexAttribArray(2);\r
+\r
+               glVertexAttribPointer(3, 1, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->coded_block_pattern));\r
+               glEnableVertexAttribArray(3);\r
+               glVertexAttribPointer(4, 2, GL_UNSIGNED_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->index));\r
+               glEnableVertexAttribArray(4);\r
+\r
+\r
+               glActiveTexture(GL_TEXTURE0);\r
+               glBindTexture(GL_TEXTURE_2D,data_blocks);\r
+               glUniform1i(blocks_loc,0);\r
+               glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);\r
+               glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);\r
+               glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);\r
+               glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);\r
+\r
+               glDrawElements(GL_TRIANGLE_STRIP, valid_macro_blocks*6,\r
+                       GL_UNSIGNED_SHORT, NULL);\r
+\r
+\r
+               /*\r
+               glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), 0);\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
+               glEnableVertexAttribArray(0);\r
+\r
+               glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
+               glEnableVertexAttribArray(1);*/\r
+\r
+       //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark4 glerror %x",glGetError());\r
+\r
+\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark6 glerror %x",glGetError());\r
+\r
+       //      glDrawElements(GL_TRIANGLE_STRIP,/*valid_macro_blocks*/4,GL_UNSIGNED_SHORT,0);\r
+               Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark7 glerror %x %x",glGetError(),valid_macro_blocks);\r
+               //cleanup\r
+\r
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());\r
                glBindBuffer(GL_ARRAY_BUFFER,0);\r
+\r
                glBindFramebuffer(GL_FRAMEBUFFER, 0);\r
+               glBindTexture(GL_TEXTURE_2D, 0);\r
+               //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark8 glerror %x",glGetError());\r
        } else {\r
                glBindFramebuffer(GL_FRAMEBUFFER, 0);\r
-               Log::getInstance()->log("GLMocoShader", Log::WARN, "framebuffer not complete");\r
+               Log::getInstance()->log("GLMocoShader", Log::WARN, "framebuffer not complete %x",status);\r
                return -1;\r
        }\r
+\r
+       glFinish(); // since the main rendering is done in a different thread we have to make sure rendering is finished before passing the texture\r
+       // call this only in the last stage of rendering the moco frame\r
        return 0;\r
 \r
 \r
@@ -255,7 +486,11 @@ int GLMocoShader::PrepareRendering(GLuint y_tex, GLuint u_tex, GLuint v_tex) { /
 \r
 int GLMocoShader::BindAttributes()\r
 {\r
-       glBindAttribLocation(shad_program,0,"vec_pos");\r
-       glBindAttribLocation(shad_program,1,"tex_coord");\r
+       glBindAttribLocation(shad_program,0,"block_pos");\r
+       glBindAttribLocation(shad_program,1,"block_edge");\r
+       glBindAttribLocation(shad_program,2,"block_types");\r
+       glBindAttribLocation(shad_program,3,"cbp");\r
+       glBindAttribLocation(shad_program,4,"index");\r
+       //glBindAttribLocation(shad_program,1,"tex_coord");\r
        return 1;\r
 }\r

diff --git a/glmocoshader.h b/glmocoshader.h
index 51ed2c7090166d4b13435d4323aba0d3d8a9214a..b37262b8313291f8fdaff007bb70ce83572df17f 100755 (executable)
--- a/glmocoshader.h
+++ b/glmocoshader.h
@@ -38,7 +38,7 @@ public:
 \r
        int uploadDataBlocks(short* blocks,unsigned int num_blocks, XvMCMacroBlock *m_blocks,unsigned int num_m_blocks);\r
 \r
-       int doMoCo(VPEOGLFrame *target, VPE_FrameBuf* source);\r
+       int doMoCo(VPEOGLFrame *target);\r
 \r
 protected:\r
        virtual int BindAttributes();\r
@@ -46,9 +46,12 @@ protected:
        GLuint data_blocks;\r
        GLuint triangles;\r
        GLuint macro_block;\r
+       GLint loc_pict_scale;\r
+       GLint blocks_loc;\r
        unsigned int valid_macro_blocks;\r
 \r
 \r
+\r
 };\r
 \r
 \r

diff --git a/osdopengl.cc b/osdopengl.cc
index 1547cafdd8a2068be515b9ba7f6c6411c93fbb05..4784aef06670c61f4cb5a73aa94a19455846e1c5 100755 (executable)
--- a/osdopengl.cc
+++ b/osdopengl.cc
@@ -125,7 +125,7 @@ int OsdOpenGL::init(void* device)
    EGLint number;\r
 \r
    if (eglChooseConfig(egl_display, attributs, &egl_ourconfig, 1, &number)==EGL_FALSE) {\r
-          Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %d",eglGetError());\r
+          Log::getInstance()->log("OSD", Log::WARN, "Choosing egl config failed! %x",eglGetError());\r
           glmutex.Unlock();\r
           return 0;\r
    }\r
@@ -137,7 +137,7 @@ int OsdOpenGL::init(void* device)
 \r
    egl_context=eglCreateContext(egl_display,egl_ourconfig,EGL_NO_CONTEXT,attr_context);\r
    if (egl_context==EGL_NO_CONTEXT) {\r
-          Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %d",eglGetError());\r
+          Log::getInstance()->log("OSD", Log::WARN, "Creating egl context failed! %x",eglGetError());\r
           glmutex.Unlock();\r
           return 0;\r
    }\r
@@ -225,6 +225,12 @@ int OsdOpenGL::init(void* device)
          return 0;\r
   }\r
 \r
+  if (!yuv444_shader.init()) {\r
+         Log::getInstance()->log("OSD", Log::WARN, "Init Yuv444 Shader failed");\r
+         glmutex.Unlock();\r
+         return 0;\r
+  }\r
+\r
  /* gen_shader=CreateShader(generic_vertex_shader, GL_VERTEX_SHADER);\r
   osd_shader=CreateShader(osd_frag_shader, GL_FRAGMENT_SHADER);\r
 \r
@@ -380,6 +386,7 @@ int OsdOpenGL::shutdown()
 \r
   osd_shader.deinit();\r
   yuv400_shader.deinit();\r
+  yuv444_shader.deinit();\r
 \r
   glClear(GL_COLOR_BUFFER_BIT);\r
   eglSwapBuffers(egl_display, egl_surface);\r
@@ -413,6 +420,7 @@ void OsdOpenGL::threadMethod()
                        if (!frame) frame=video->getReadyOGLFrame();\r
                        if (frame) {\r
                                InternalRendering(frame);\r
+                               MILLISLEEP(1500);\r
                                lastrendertime=getTimeMS();\r
                                video->returnOGLFrame(frame); //please recycle it\r
                                frame=NULL;\r
@@ -566,6 +574,7 @@ void OsdOpenGL::InternalRendering(VPEOGLFrame* frame){
 \r
        glViewport(0, 0, display_width,display_height);\r
 \r
+       glClearColor(0.0f,0.0f,0.0f,1.f);\r
        glClear(GL_COLOR_BUFFER_BIT);\r
 \r
 \r
@@ -605,7 +614,13 @@ void OsdOpenGL::InternalRendering(VPEOGLFrame* frame){
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);\r
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);*/\r
 \r
-               yuv400_shader.PrepareRendering(frame->textures[0],frame->textures[1],frame->textures[2]);\r
+               switch (frame->type) {\r
+               case 1:\r
+                       yuv400_shader.PrepareRendering(frame->textures[0],frame->textures[1],frame->textures[2]);break;\r
+               case 2:\r
+                       yuv444_shader.PrepareRendering(frame->textures[0]);break;\r
+               }\r
+\r
 \r
 \r
 \r

diff --git a/osdopengl.h b/osdopengl.h
index 5b354e1d59af7529b6fb53ee0aba70f1d682d78e..75288f26065dd2f9f957bcd31afbbe24c79016f3 100755 (executable)
--- a/osdopengl.h
+++ b/osdopengl.h
@@ -38,6 +38,7 @@
 \r
 #include "glosdshader.h"\r
 #include "glyuv400shader.h"\r
+#include "glyuv444shader.h"\r
 \r
 \r
 \r
@@ -141,6 +142,7 @@ private:
        GLint osd_sampler_loc;*/\r
        GLOsdShader osd_shader;\r
        GLYuv400Shader yuv400_shader;\r
+       GLYuv444Shader yuv444_shader;\r
 \r
 \r
 \r

diff --git a/videovpeogl.cc b/videovpeogl.cc
index 8b900098242d7db5d4f3be02687f5f6d7cd4a329..3a8ea287069bb0c989b47660576652d004123677 100755 (executable)
--- a/videovpeogl.cc
+++ b/videovpeogl.cc
@@ -113,7 +113,7 @@ int VideoVPEOGL::initUsingOSDObjects()
        egl_display=i_egl_display;
        egl_context=eglCreateContext(egl_display,i_egl_config,i_egl_context,attr_context);
        if (egl_context==EGL_NO_CONTEXT) {
-                Log::getInstance()->log("Video", Log::WARN, "Creating egl context failed! %d",eglGetError());
+                Log::getInstance()->log("Video", Log::WARN, "Creating egl context failed! %x",eglGetError());
                 return 0;
        }
        // We create a dummy surface here, in order to allow two contexts
@@ -123,7 +123,7 @@ int VideoVPEOGL::initUsingOSDObjects()
        };
        egl_surface=eglCreatePbufferSurface(egl_display,i_egl_config,attr_pbuffer);
        if (egl_surface==EGL_NO_SURFACE) {
-                Log::getInstance()->log("Video", Log::WARN, "Creating egl pbuffer failed! %d",eglGetError());
+                Log::getInstance()->log("Video", Log::WARN, "Creating egl pbuffer failed! %x",eglGetError());
                 return 0;
        }
 
@@ -271,13 +271,13 @@ int VideoVPEOGL::AllocateYUV400OglTexture(VPEOGLFrame* outframe,int width,int he
        return 1;
 }
 
-int VideoVPEOGL::AllocateYUV444OglTexture(VPEOGLFrame* outframe,int width,int height,int stride)
+int VideoVPEOGL::AllocateYUV444OglTexture(VPEOGLFrame* outframe,int width,int height)
 {
        Log::getInstance()->log("Video", Log::NOTICE, "Allocate ogl texture 444");
        // Y
        glGenTextures(1, &outframe->textures[0]);
        glBindTexture(GL_TEXTURE_2D, outframe->textures[0]);
-       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, stride, height, 0, GL_RGBA,
+       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
                                GL_UNSIGNED_BYTE, NULL);
        outframe->textures[1]=outframe->textures[2]=0; // no handles here
 
@@ -287,7 +287,7 @@ int VideoVPEOGL::AllocateYUV444OglTexture(VPEOGLFrame* outframe,int width,int he
        outframe->type=2;
        outframe->height=height;
        outframe->width=width;
-       outframe->stride=stride;
+       outframe->stride=width; // does not make any sense otherwiese
        return 1;
 }
 
@@ -369,7 +369,7 @@ void VideoVPEOGL::threadMethod()
                                        if (decoding_mode==VPE_NO_XVMC) {
                                                if (!AllocateYUV400OglTexture(out_frame,width,height,dec_frame_libav_uploading->linesize[0])) failed=true;
                                        }else {
-                                               if (!AllocateYUV444OglTexture(out_frame,width,height,dec_frame_libav_uploading->linesize[0])) failed=true; //We use a YUV 444 texture in this case
+                                               if (!AllocateYUV444OglTexture(out_frame,width,height)) failed=true; //We use a YUV 444 texture in this case
                                                // the shaders are easier to implement
                                        }
                                }
@@ -411,6 +411,7 @@ void VideoVPEOGL::threadMethod()
                                                        } else {
                                                                //DCT Blocks upload
                                                        }
+                                                       moco_shader->doMoCo(out_frame);
 
                                                // Excute motion compensation
                                                }
@@ -1528,7 +1529,7 @@ int VideoVPEOGL::get_buffer_libav(struct AVCodecContext *c, AVFrame *pic)
                pix_xvmc->allocated_data_blocks=num_dct_blocks;
                if (c->pix_fmt==PIX_FMT_XVMC_MPEG2_IDCT) pix_xvmc->idct=1;
                else pix_xvmc->idct=0;
-               pix_xvmc->unsigned_intra=0; // let see what happens
+               pix_xvmc->unsigned_intra=1; // let see what happens
                pix_xvmc->p_surface=(XvMCSurface*)frame_buf->pict_num;
                pix_xvmc->start_mv_blocks_num=0;
                pix_xvmc->filled_mv_blocks_num=0;

diff --git a/videovpeogl.h b/videovpeogl.h
index 95620e853afb40bbeb0400c3543ce3c5176f46e1..c09876221caf62b4ba4a7f68a30cdf47b67f2b9b 100755 (executable)
--- a/videovpeogl.h
+++ b/videovpeogl.h
@@ -316,7 +316,7 @@ class VideoVPEOGL : public Video, public Thread_TYPE
        Mutex ogl_frame_mutex;\r
 \r
        int AllocateYUV400OglTexture(VPEOGLFrame* outframe,int width,int height,int stride);\r
-       int AllocateYUV444OglTexture(VPEOGLFrame* outframe,int width,int height,int stride);\r
+       int AllocateYUV444OglTexture(VPEOGLFrame* outframe,int width,int height);\r
 \r
        virtual void threadMethod();\r
        virtual void threadPostStopCleanup();\r