glmocoshader.cc

   1 /*\r
   2     Copyright 2012 Marten Richter\r
   3 \r
   4     This file is part of VOMP.\r
   5 \r
   6     VOMP is free software; you can redistribute it and/or modify\r
   7     it under the terms of the GNU General Public License as published by\r
   8     the Free Software Foundation; either version 2 of the License, or\r
   9     (at your option) any later version.\r
  10 \r
  11     VOMP is distributed in the hope that it will be useful,\r
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14     GNU General Public License for more details.\r
  15 \r
  16     You should have received a copy of the GNU General Public License\r
  17     along with VOMP; if not, write to the Free Software\r
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\r
  19 */\r
  20 #include "glmocoshader.h"\r
  21 #include "videovpeogl.h"\r
  22 \r
  23 #define BLOCK_TEXTURE_WIDTH 2048\r
  24 #define BLOCK_TEXTURE_HEIGHT 1024\r
  25 #define BLOCK_SIZE 64\r
  26 #define BLOCK_PER_ROW 32\r
  27 \r
  28 const GLchar moco_vertex_shader[] =\r
  29                 "attribute vec4 block_pos;\n"\r
  30                 "attribute vec2 block_edge;\n"\r
  31                 "attribute vec4 block_types;\n"\r
  32                 "attribute vec2 index;\n"\r
  33                 "attribute float cbp;\n"\r
  34                 "uniform vec2 pict_scale;\n"\r
  35         //      "attribute vec2 tex_coord;\n"\r
  36                 "varying vec4 out_yblockpos_x;\n"\r
  37                 "varying vec4 out_yblockpos_y;\n"\r
  38                 "varying vec4 out_uvblockpos_xy;\n"\r
  39                 "varying vec2 out_block_edge;\n"\r
  40                 "varying vec4 out_block_types;\n"\r
  41 \r
  42                 "const float one=1.0;\n"\r
  43                 "const float c1024=1024.0;\n"\r
  44                 "const float c32=32.0;\n"\r
  45         //      "const float c1over32=0.03125;\n"\r
  46                 "const float c1over32=1./32.;\n"\r
  47 \r
  48 \r
  49                 "const float c65536=65536.;\n"\r
  50 \r
  51 \r
  52 \r
  53                 "const vec4  y_cbp=vec4(1.0,2.0,4.0,8.0);\n"\r
  54                 "const vec2  uv_cbp=vec2(16.0,32.0);\n"\r
  55                 "void main()\n"\r
  56                 "{\n"\r
  57                 // calculate cbp\r
  58                 "  vec4 cbp_vec=vec4(cbp,cbp,cbp,cbp);\n"\r
  59                 "  vec4 fmod_cbp_y=mod(cbp_vec,y_cbp);\n"\r
  60                 "  vec2 fmod_cbp_uv=mod(cbp_vec.xy,uv_cbp);\n"\r
  61                 "  fmod_cbp_y.x=0.;\n"\r
  62                 "  fmod_cbp_y=sign(vec4(fmod_cbp_y.yzw,fmod_cbp_uv.x)-fmod_cbp_y);\n"\r
  63                 "  fmod_cbp_uv=sign(vec2(fmod_cbp_uv.y,cbp)-fmod_cbp_uv);\n"\r
  64                 // resulting vector should indicate with block is present\r
  65                 // now transform it to a sum (TODO vectorize this)\r
  66                 "  vec4 fmod_cbp_y2=fmod_cbp_y;\n"\r
  67                 "  vec2 fmod_cbp_uv2=fmod_cbp_uv;\n"\r
  68                 "  fmod_cbp_y2.y+=fmod_cbp_y2.x;\n"\r
  69                 "  fmod_cbp_y2.z+=fmod_cbp_y2.y;\n"\r
  70                 "  fmod_cbp_y2.w+=fmod_cbp_y2.z;\n"\r
  71                 "  fmod_cbp_uv2.x+=fmod_cbp_y2.w;\n"\r
  72                 "  fmod_cbp_uv2.y+=fmod_cbp_uv2.x;\n"\r
  73 \r
  74                 // now calculate their position inside the short array\r
  75                 "  float m_index=index.x/*+index.y*c65536*/-one;\n" //Not Endian save\r
  76                 "  fmod_cbp_y2+=m_index;\n" //shift to the blocks\r
  77                 "  fmod_cbp_uv2+=m_index;\n"\r
  78                 //"  out_yblockpos_x=(mod(fmod_cbp_y2,c32));\n"\r
  79             //"  out_uvblockpos_xy.xy=(mod(fmod_cbp_uv2,c32));\n"\r
  80                 //"  out_yblockpos_y=floor((fmod_cbp_y2)/c32);\n"\r
  81                 //"  out_uvblockpos_xy.zw=floor((fmod_cbp_uv2)/c32);\n"\r
  82 \r
  83                 "  out_yblockpos_y=floor((fmod_cbp_y2)*c1over32);\n"\r
  84                 "  out_uvblockpos_xy.zw=floor((fmod_cbp_uv2)*c1over32);\n"\r
  85                 "  out_yblockpos_x=fmod_cbp_y2-c32*out_yblockpos_y;\n"\r
  86             "  out_uvblockpos_xy.xy=fmod_cbp_uv2-c32*out_uvblockpos_xy.zw;\n"\r
  87 \r
  88 \r
  89 \r
  90                 //Kick out uncoded blocks\r
  91                 "  out_yblockpos_y-=sign(fmod_cbp_y-one)*c1024;\n"\r
  92                 "  out_uvblockpos_xy.zw-=sign(fmod_cbp_uv-one)*c1024;\n"\r
  93 \r
  94 \r
  95                 "  out_block_edge=block_edge;\n"\r
  96                 "  out_block_types=block_types;\n"\r
  97                 "  vec4 out_pos=block_pos;\n"\r
  98                 "  out_pos.xy+=block_edge;\n"\r
  99                 "  out_pos.xy*=pict_scale;\n"\r
 100                 "  out_pos.xy-=vec2(one,one);"\r
 101                 "  out_pos.zw=vec2(one,one);"\r
 102                 " gl_Position=out_pos;\n"\r
 103                 "}\n";\r
 104 \r
 105 const GLchar moco_frag_shader[] =\r
 106                 "precision mediump float;\n"\r
 107                 "uniform sampler2D blocks;\n"\r
 108                 "varying vec4 out_yblockpos_x;\n"\r
 109                 "varying vec4 out_yblockpos_y;\n"\r
 110                 "varying vec4 out_uvblockpos_xy;\n"\r
 111                 "varying vec2 out_block_edge;\n"\r
 112                 "varying vec4 out_block_types;\n"\r
 113 \r
 114                 "const float halfst=0.5;\n"\r
 115                 "const float ctwo=2.0;\n"\r
 116                 "const float cone=1.0;\n"\r
 117                 "const float sieben=7.0;\n"\r
 118                 "const float acht=8.0;\n"\r
 119                 "const float s8=1./8.;\n"\r
 120                 "const float s16=1./16.;\n"\r
 121                 "const float c1over2048=1./2048.;\n"\r
 122                 "const float c1over1024=1./1024.;\n"\r
 123                 "const float c255=255.;\n"\r
 124                 "const float c65280=65280.;\n"\r
 125                 "const float c65536=65536.;\n"\r
 126                 "const float cstep=32767.;\n"\r
 127                 "\n"\r
 128                 "float unpack_short(vec2 income) {\n"\r
 129                 "   float temp=income.y*c65280+income.x*c255;\n"\r
 130                 "   temp-=step(cstep,temp)*c65536;\n"\r
 131                 "   return abs(temp/c255);\n" //temporary work around\r
 132                 "}"\r
 133         //      "uniform sampler2D textureV;\n"\r
 134         //      "uniform sampler2D textureY;\n"\r
 135 //              "varying vec2 out_texCoord;\n"\r
 136                 "void main()\n"\r
 137                 "{\n"\r
 138                 // first figure out the block num for y, first decide between up and down, fix me field\r
 139         //non field code\r
 140                 " vec4 ypos_temp1;\n"\r
 141                 " bool upper_half;\n"\r
 142                 " float line_step;\n"\r
 143                 " if (out_block_types.w!=0.) {\n" //test the dct type\r
 144                 "  upper_half=mod(floor(out_block_edge.y*acht),ctwo)==cone;\n"\r
 145                 "  line_step=cone;\n"\r
 146                 "}else{\n"\r
 147                 "  upper_half=halfst<out_block_edge.y;\n"\r
 148                 "  line_step=ctwo;\n"\r
 149                 "}\n"\r
 150                 " if (upper_half) {\n"\r
 151                 "  ypos_temp1=vec4(out_yblockpos_x.z,out_yblockpos_y.z,out_yblockpos_x.w,out_yblockpos_y.w);\n"\r
 152                 "  } else {\n"\r
 153                 "    ypos_temp1=vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y);\n"\r
 154                 " }\n"\r
 155     //  " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"\r
 156         //      "                  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
 157                 //field code\r
 158         //      " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"\r
 159         //                      "                  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
 160 \r
 161                 //decide between left and right\r
 162                 " vec4 ypos_temp2;\n"\r
 163                 "if (halfst<out_block_edge.x){\n"\r
 164                 "  ypos_temp2.xy=ypos_temp1.zw;\n"\r
 165                 " }else {\n"\r
 166                 "  ypos_temp2.xy=ypos_temp1.xy;\n"\r
 167                 " }\n"\r
 168                 //now get the intra 8x8 Block coordinates\r
 169                 " vec2 ypos_temp3=floor(mod(out_block_edge*vec2(ctwo,line_step),cone)*acht);\n"\r
 170                 " ypos_temp2.x=(ypos_temp3.x+(ypos_temp3.y+acht*(ypos_temp2.x))*acht);\n"\r
 171                 //" bool subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"\r
 172                 " bool subsample=mod(ypos_temp3.x,ctwo)==cone;\n"\r
 173                 " ypos_temp2.x*=halfst;\n"\r
 174                 " ypos_temp2.xy*=c1over1024;\n"\r
 175                 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data\r
 176                 "if (subsample){\n"\r
 177                 "  ypos_temp2.xy=ypos_temp1.zw;\n"\r
 178                 //"  ypos_temp2=vec2(cone,0.);\n"\r
 179                 " }else {\n"\r
 180                 "  ypos_temp2.xy=ypos_temp1.xy;\n"\r
 181                 " }\n"\r
 182                 " gl_FragColor.r=unpack_short(ypos_temp2.rg);\n"\r
 183 \r
 184                 //now uv\r
 185                 " ypos_temp3=floor(out_block_edge*acht);\n"\r
 186                 " ypos_temp2.yw=floor(out_uvblockpos_xy.zw);\n"\r
 187                 " ypos_temp2.xz=(ypos_temp3.x+(ypos_temp3.y+acht*(out_uvblockpos_xy.xy))*acht);\n"\r
 188                                 //" bool subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"\r
 189                 " subsample=mod(ypos_temp3.x,ctwo)==cone;\n"\r
 190                 " ypos_temp2.xz*=halfst;\n"\r
 191                 " ypos_temp2*=c1over1024;\n"\r
 192 \r
 193                 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data\r
 194                 " if (subsample){\n"\r
 195                 "  ypos_temp2.xy=ypos_temp1.zw;\n"\r
 196                 " }else {\n"\r
 197                 "  ypos_temp2.xy=ypos_temp1.xy;\n"\r
 198                 " }\n"\r
 199                 " gl_FragColor.g=unpack_short(ypos_temp2.rg);\n"\r
 200 \r
 201                 " ypos_temp1=texture2D(blocks,ypos_temp2.zw);\n" // now select the right data\r
 202                 " if (subsample){\n"\r
 203                 "  ypos_temp2.xy=ypos_temp1.zw;\n"\r
 204                 " }else {\n"\r
 205                 "  ypos_temp2.xy=ypos_temp1.xy;\n"\r
 206                 " }\n"\r
 207                 " gl_FragColor.b=unpack_short(ypos_temp2.rg);\n"\r
 208 \r
 209 \r
 210                 //" ypos_temp2=mix(ypos_temp1.rg,ypos_temp1.ba,step(c1over2047,mod(ypos_temp2.x,c1over1023)));\n" //activate this\r
 211 \r
 212 \r
 213                 //" gl_FragColor.r=subsample/acht;\n" //signed later TODO\r
 214                 //" gl_FragColor.g=0.5;\n"\r
 215                 //" gl_FragColor.b=0.5;\n"\r
 216                 " gl_FragColor.a=1.0;\n"\r
 217                 //" vec4 blocks=texture2D(blocks,gl_FragCoord.xy/600.);\n"\r
 218 //              "help.x=texture2D(textureY,out_texCoord).r;\n"\r
 219 //              "help.y=texture2D(textureU,out_texCoord).r;\n"\r
 220 //              "help.z=texture2D(textureV,out_texCoord).r;\n" //-uv_corr;\n"\r
 221    //   "  gl_FragColor.rgba=blocks;\n"\r
 222         //      "  gl_FragColor.rgba=vec4(0.7,0.5,0.5,1.0);\n"\r
 223                 //"  gl_FragColor.a=1.;\n"\r
 224                 "}\n";\r
 225 \r
 226 GLMocoShader::GLMocoShader(): GLShader("GLMocoShader")\r
 227 {\r
 228 \r
 229         frame_buf=0;\r
 230         blocks_loc=0;\r
 231 }\r
 232 \r
 233 GLMocoShader::~GLMocoShader()\r
 234 {\r
 235         //parent does everything\r
 236 }\r
 237 \r
 238 int GLMocoShader::init() {\r
 239 \r
 240         if (!initShaders(moco_vertex_shader, moco_frag_shader)) {\r
 241                 Log::getInstance()->log("GLMocoShader", Log::ERR, "init Shaders failed for GLMocoShader");\r
 242                 return 0;\r
 243         }\r
 244         loc_pict_scale = glGetUniformLocation(shad_program, "pict_scale");\r
 245         blocks_loc = glGetUniformLocation(shad_program, "blocks");\r
 246 \r
 247 //      frame_sampler_locY = glGetUniformLocation(shad_program, "textureY");\r
 248         // Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locY,glGetError());\r
 249 //      frame_sampler_locU = glGetUniformLocation(shad_program, "textureU");\r
 250         //Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locU,glGetError());\r
 251 //      frame_sampler_locV = glGetUniformLocation(shad_program, "textureV");\r
 252         glGenFramebuffers(1, &frame_buf);\r
 253         //Log::getInstance()->log("GLMocoShader", Log::WARN, "genframe bufmark1 glerror %x",glGetError());\r
 254         glGenTextures(1, &data_blocks);\r
 255         glBindTexture(GL_TEXTURE_2D, data_blocks);\r
 256         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, BLOCK_TEXTURE_WIDTH >>1, BLOCK_TEXTURE_HEIGHT, 0, GL_RGBA,\r
 257                                 GL_UNSIGNED_BYTE, NULL);\r
 258         char buffer[BLOCK_TEXTURE_WIDTH*4];\r
 259         memset(buffer,0,BLOCK_TEXTURE_WIDTH*4); // the last line is black, simplifies the shader algorithms\r
 260 \r
 261         glTexSubImage2D(GL_TEXTURE_2D,0,0,BLOCK_TEXTURE_HEIGHT-1,\r
 262                         1024,1,\r
 263                         GL_RGBA,GL_UNSIGNED_BYTE,\r
 264                         buffer);\r
 265 \r
 266         glGenBuffers(1,&macro_block);\r
 267         glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 268         glBufferData(GL_ARRAY_BUFFER,4096*4*sizeof(XvMCMacroBlock),NULL,GL_DYNAMIC_DRAW);\r
 269         valid_macro_blocks=0;\r
 270 \r
 271 \r
 272         glGenBuffers(1,&triangles);\r
 273         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);\r
 274         GLushort *tri_indices=(GLushort *)malloc(sizeof(GLushort)*4096*6);\r
 275         if (!tri_indices) {\r
 276                 Log::getInstance()->log("GLMocoShader", Log::WARN, "allocating triindices failed");\r
 277                 return 0;\r
 278         }\r
 279         GLushort *tri_indices_run=tri_indices;\r
 280         for (int i=0;i<4096;i++) {\r
 281                 *tri_indices_run=i+0*4096;  //strip\r
 282                 tri_indices_run++;\r
 283                 *tri_indices_run=i+2*4096;  //strip\r
 284                 tri_indices_run++;\r
 285                 *tri_indices_run=i+1*4096;  //strip\r
 286                 tri_indices_run++;\r
 287                 *tri_indices_run=i+3*4096;  //strip\r
 288                 tri_indices_run++;\r
 289                 *tri_indices_run=i+3*4096;  //strip\r
 290                 tri_indices_run++;\r
 291                 *tri_indices_run=i+1+0*4096;  //strip\r
 292                 tri_indices_run++;\r
 293         }\r
 294 \r
 295 \r
 296 \r
 297 \r
 298 \r
 299         glBufferData(GL_ELEMENT_ARRAY_BUFFER,4096*6*sizeof(GLushort),tri_indices,GL_STREAM_DRAW);\r
 300         free(tri_indices);\r
 301 \r
 302         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);\r
 303         glBindBuffer(GL_ARRAY_BUFFER,0);\r
 304 \r
 305 \r
 306 \r
 307         return 1;\r
 308 \r
 309 }\r
 310 \r
 311 int GLMocoShader::deinit()\r
 312 {\r
 313         glDeleteFramebuffers(1, &frame_buf);\r
 314         glDeleteTextures(1, &data_blocks);\r
 315         return deinitShaders();\r
 316 }\r
 317 \r
 318 \r
 319 \r
 320 int GLMocoShader::uploadDataBlocks(short* blocks,unsigned int num_blocks, XvMCMacroBlock *m_blocks,unsigned int num_m_blocks)\r
 321 {\r
 322         unsigned int height=(num_blocks)/(BLOCK_PER_ROW);\r
 323 \r
 324         glBindTexture(GL_TEXTURE_2D, data_blocks);\r
 325         glPixelStorei(GL_UNPACK_ALIGNMENT,1);\r
 326 \r
 327 \r
 328 \r
 329 \r
 330         Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark1 glerror %x %d",glGetError(),height);\r
 331         glTexSubImage2D(GL_TEXTURE_2D,0,0,0,\r
 332                 BLOCK_TEXTURE_WIDTH>>1,height,\r
 333                 GL_RGBA,GL_UNSIGNED_BYTE,\r
 334                 blocks);\r
 335         Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
 336         glTexSubImage2D(GL_TEXTURE_2D,0,0,height+1,\r
 337                         (num_blocks%BLOCK_PER_ROW)>>1,1,\r
 338                         GL_RGBA,GL_UNSIGNED_BYTE,\r
 339                         blocks);\r
 340 \r
 341         Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
 342 \r
 343 \r
 344 \r
 345         glBindTexture(GL_TEXTURE_2D, 0);\r
 346 \r
 347         valid_macro_blocks=num_m_blocks;\r
 348         glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 349         XvMCMacroBlock *m_blocks_run=m_blocks;\r
 350         XvMCMacroBlock *m_blocks_end=m_blocks+num_m_blocks;\r
 351         while (m_blocks_run!=m_blocks_end) {\r
 352                 m_blocks_run->pad0=0xFF00;\r
 353                 m_blocks_run++;\r
 354         }\r
 355         // debug\r
 356 /*      m_blocks[0].x=0;\r
 357         m_blocks[0].y=0;\r
 358         m_blocks[3]=m_blocks[2]=m_blocks[1]=m_blocks[0];\r
 359         m_blocks[0].pad0=0xFF00;\r
 360         m_blocks[1].pad0=0xFFFF;\r
 361         m_blocks[2].pad0=0x0000;\r
 362         m_blocks[3].pad0=0x00FF;\r
 363         m_blocks[1].x=0;\r
 364         m_blocks[1].y=0;\r
 365         m_blocks[2].x=0;\r
 366         m_blocks[2].y=0;\r
 367         m_blocks[3].x=0;\r
 368         m_blocks[3].y=0;*/\r
 369 \r
 370         glBufferSubData(GL_ARRAY_BUFFER, 0* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),\r
 371                         m_blocks);\r
 372 \r
 373 \r
 374         m_blocks_run = m_blocks;\r
 375         m_blocks_end = m_blocks + num_m_blocks;\r
 376         while (m_blocks_run != m_blocks_end) {\r
 377                 m_blocks_run->pad0 = 0xFFFF;\r
 378                 m_blocks_run++;\r
 379         }\r
 380         glBufferSubData(GL_ARRAY_BUFFER, 4096* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),\r
 381                         m_blocks);\r
 382 \r
 383 \r
 384         m_blocks_run = m_blocks;\r
 385         m_blocks_end = m_blocks + num_m_blocks;\r
 386         while (m_blocks_run != m_blocks_end) {\r
 387                 m_blocks_run->pad0 = 0x0000;\r
 388                 m_blocks_run++;\r
 389         }\r
 390         glBufferSubData(GL_ARRAY_BUFFER, 2 * 4096* sizeof(XvMCMacroBlock),\r
 391                         num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);\r
 392 \r
 393 \r
 394         m_blocks_run = m_blocks;\r
 395         m_blocks_end = m_blocks + num_m_blocks;\r
 396         while (m_blocks_run != m_blocks_end) {\r
 397                 m_blocks_run->pad0 = 0x00FF;\r
 398                 m_blocks_run++;\r
 399         }\r
 400         glBufferSubData(GL_ARRAY_BUFFER, 3 * 4096* sizeof(XvMCMacroBlock),\r
 401                         num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);\r
 402 \r
 403 \r
 404         glBindBuffer(GL_ARRAY_BUFFER,0);\r
 405 \r
 406         return 1;\r
 407 \r
 408 \r
 409 \r
 410 }\r
 411 \r
 412 int GLMocoShader::doMoCo(VPEOGLFrame *target)\r
 413 {\r
 414 \r
 415 //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-2 glerror %x %x",glGetError(),frame_buf);\r
 416 \r
 417         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-1 glerror %x %x",glGetError(),frame_buf);\r
 418         glBindFramebuffer(GL_FRAMEBUFFER, frame_buf);\r
 419         Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1 glerror %x %x %x",glGetError(),target->textures[0],target->textures[1]);\r
 420 \r
 421 \r
 422         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,\r
 423                         GL_TEXTURE_2D, target->textures[0], 0);\r
 424         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1apres glerror %x",glGetError());\r
 425 \r
 426 \r
 427 \r
 428 \r
 429         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2 glerror %x",glGetError());\r
 430 \r
 431         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2a glerror %x",glGetError());\r
 432 \r
 433         int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);\r
 434         if (status == GL_FRAMEBUFFER_COMPLETE) {\r
 435                 glViewport(0, 0, target->width,target->height);\r
 436         //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2b glerror %x",glGetError());\r
 437 \r
 438                 XvMCMacroBlock * helperp=NULL;\r
 439 \r
 440                 glClearColor(0.0f,0.5f,0.5f,1.f); //this black\r
 441                 glClear(GL_COLOR_BUFFER_BIT);\r
 442                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2c glerror %x",glGetError());\r
 443 \r
 444                 glUseProgram(shad_program);\r
 445                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
 446 \r
 447 \r
 448                 const GLfloat pict_scale[]={  32./((float)target->width),32./((float)target->height)};\r
 449 \r
 450                 glUniform2fv(loc_pict_scale,1,(const GLfloat*)&pict_scale);\r
 451 \r
 452 \r
 453 \r
 454                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);\r
 455                                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());\r
 456                 glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 457 \r
 458 \r
 459 \r
 460                 glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,\r
 461                                 sizeof(XvMCMacroBlock), NULL);\r
 462 \r
 463                 glEnableVertexAttribArray(0);\r
 464 \r
 465                 glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));\r
 466                 glEnableVertexAttribArray(1);\r
 467 \r
 468                 glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->macroblock_type));\r
 469                 glEnableVertexAttribArray(2);\r
 470 \r
 471                 glVertexAttribPointer(3, 1, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->coded_block_pattern));\r
 472                 glEnableVertexAttribArray(3);\r
 473                 glVertexAttribPointer(4, 2, GL_UNSIGNED_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->index));\r
 474                 glEnableVertexAttribArray(4);\r
 475 \r
 476 \r
 477                 glActiveTexture(GL_TEXTURE0);\r
 478                 glBindTexture(GL_TEXTURE_2D,data_blocks);\r
 479                 glUniform1i(blocks_loc,0);\r
 480                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);\r
 481                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);\r
 482                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);\r
 483                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);\r
 484 \r
 485                 glDrawElements(GL_TRIANGLE_STRIP, valid_macro_blocks*6,\r
 486                         GL_UNSIGNED_SHORT, NULL);\r
 487 \r
 488 \r
 489                 /*\r
 490                 glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), 0);\r
 491                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
 492                 glEnableVertexAttribArray(0);\r
 493 \r
 494                 glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));\r
 495                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
 496                 glEnableVertexAttribArray(1);*/\r
 497 \r
 498         //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark4 glerror %x",glGetError());\r
 499 \r
 500 \r
 501                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark6 glerror %x",glGetError());\r
 502 \r
 503         //      glDrawElements(GL_TRIANGLE_STRIP,/*valid_macro_blocks*/4,GL_UNSIGNED_SHORT,0);\r
 504                 Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark7 glerror %x %x",glGetError(),valid_macro_blocks);\r
 505                 //cleanup\r
 506 \r
 507                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);\r
 508                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());\r
 509                 glBindBuffer(GL_ARRAY_BUFFER,0);\r
 510 \r
 511                 glBindFramebuffer(GL_FRAMEBUFFER, 0);\r
 512                 glBindTexture(GL_TEXTURE_2D, 0);\r
 513                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark8 glerror %x",glGetError());\r
 514         } else {\r
 515                 glBindFramebuffer(GL_FRAMEBUFFER, 0);\r
 516                 Log::getInstance()->log("GLMocoShader", Log::WARN, "framebuffer not complete %x",status);\r
 517                 return -1;\r
 518         }\r
 519 \r
 520         glFinish(); // since the main rendering is done in a different thread we have to make sure rendering is finished before passing the texture\r
 521         // call this only in the last stage of rendering the moco frame\r
 522         return 0;\r
 523 \r
 524 \r
 525 \r
 526 }\r
 527 \r
 528 /*\r
 529 \r
 530 int GLMocoShader::PrepareRendering(GLuint y_tex, GLuint u_tex, GLuint v_tex) { // This Function setups the rendering pipeline according to the shaders standards\r
 531 \r
 532         //Log::getInstance()->log("OSD", Log::WARN, "mark1 glerror %x",glGetError());\r
 533 \r
 534 \r
 535         //Log::getInstance()->log("OSD", Log::WARN, "mark2 glerror %x",glGetError());\r
 536 \r
 537 \r
 538         glActiveTexture( GL_TEXTURE2);\r
 539         glBindTexture(GL_TEXTURE_2D, v_tex);\r
 540         glUniform1i(frame_sampler_locV, 2);\r
 541         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
 542         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
 543 \r
 544         glActiveTexture( GL_TEXTURE1);\r
 545         glBindTexture(GL_TEXTURE_2D, u_tex);\r
 546         glUniform1i(frame_sampler_locU, 1);\r
 547         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
 548         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
 549 \r
 550         glActiveTexture( GL_TEXTURE0);\r
 551         glBindTexture(GL_TEXTURE_2D, y_tex);\r
 552         glUniform1i(frame_sampler_locY, 0);\r
 553         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
 554         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
 555         return 1;\r
 556 \r
 557 }*/\r
 558 \r
 559 int GLMocoShader::BindAttributes()\r
 560 {\r
 561         glBindAttribLocation(shad_program,0,"block_pos");\r
 562         glBindAttribLocation(shad_program,1,"block_edge");\r
 563         glBindAttribLocation(shad_program,2,"block_types");\r
 564         glBindAttribLocation(shad_program,3,"cbp");\r
 565         glBindAttribLocation(shad_program,4,"index");\r
 566         //glBindAttribLocation(shad_program,1,"tex_coord");\r
 567         return 1;\r
 568 }\r