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 // This implementation is for framed coded pictures only!\r
  29 // I did not find any DVB recording with field coded pictures\r
  30 // so I do not think they exist here, anyway I suspect we\r
  31 // need a totally different shader in this case\r
  32 // so first write the frame coded shader\r
  33 // and then later add if necessary field based support.\r
  34 \r
  35 const GLchar moco_vertex_shader[] =\r
  36                 "attribute vec4 block_pos;\n"\r
  37                 "attribute vec2 block_edge;\n"\r
  38                 "attribute vec4 block_types;\n"\r
  39                 "attribute vec2 index;\n"\r
  40                 "attribute vec4 PMV1;\n"\r
  41                 "attribute vec4 PMV2;\n"\r
  42                 "attribute float cbp;\n"\r
  43                 "uniform vec2 pict_scale;\n"\r
  44         //      "attribute vec2 tex_coord;\n"\r
  45                 "varying vec4 out_yblockpos_x;\n"\r
  46                 "varying vec4 out_yblockpos_y;\n"\r
  47                 "varying vec4 out_uvblockpos_xy;\n"\r
  48                 "varying vec2 out_block_edge;\n"\r
  49                 "varying vec4 out_misc_info;\n"\r
  50 \r
  51                 "varying float out_unsupported;\n"\r
  52                 "varying vec4 out_moco_pos;\n"\r
  53                 "varying vec4 out_moco_forward;\n"\r
  54                 "varying vec4 out_moco_backward;\n"\r
  55 \r
  56 \r
  57                 "const float one=1.0;\n"\r
  58                 "const float czero=0.0;\n"\r
  59                 "const float chalf=0.5;\n"\r
  60                 "const float c1024=1024.0;\n"\r
  61                 "const float c32=32.0;\n"\r
  62         //      "const float c1over32=0.03125;\n"\r
  63                 "const float c1over32=1./32.;\n"\r
  64 \r
  65 \r
  66                 "const float c65536=65536.;\n"\r
  67 \r
  68 \r
  69 \r
  70                 "const vec4  y_cbp=vec4(1.0,2.0,4.0,8.0);\n"\r
  71                 "const vec3  uv_cbp=vec3(16.0,32.0,64.0);\n"\r
  72                 "void main()\n"\r
  73                 "{\n"\r
  74                 // calculate cbp\r
  75                 //"  vec4 cbp_vec=vec4(cbp,cbp,cbp,cbp);\n"\r
  76 \r
  77                 // old cbp code\r
  78         //      "  vec4 fmod_cbp_y=mod(cbp_vec,y_cbp);\n"\r
  79         //      "  vec2 fmod_cbp_uv=mod(cbp_vec.xy,uv_cbp.xy);\n"\r
  80         //      "  fmod_cbp_y.x=0.;\n"\r
  81         //      "  fmod_cbp_y=sign(vec4(fmod_cbp_y.yzw,fmod_cbp_uv.x)-fmod_cbp_y);\n"\r
  82         //      "  fmod_cbp_uv=sign(vec2(fmod_cbp_uv.y,cbp)-fmod_cbp_uv);\n"\r
  83                 // resulting vector should indicate with block is present\r
  84                 // now transform it to a sum (TODO vectorize this)\r
  85 \r
  86 //this code is better but nor really working\r
  87         /*      "  vec4 fmod_cbp_y=mod(cbp_vec,vec4(uv_cbp.zyx,y_cbp.w));\n"\r
  88                 "  vec2 fmod_cbp_uv=mod(cbp_vec.xy,y_cbp.zy);\n"\r
  89                 "  fmod_cbp_y=vec4(lessThanEqual(vec4(uv_cbp.yx,y_cbp.wz),fmod_cbp_y));\n"\r
  90             "  fmod_cbp_uv=vec2(lessThanEqual(y_cbp.yx,fmod_cbp_uv));\n"\r
  91 \r
  92                 "  vec4 fmod_cbp_y2=fmod_cbp_y;\n"\r
  93                 "  vec2 fmod_cbp_uv2=fmod_cbp_uv;\n"\r
  94                 "  fmod_cbp_y2.y+=fmod_cbp_y2.x;\n"\r
  95                 "  fmod_cbp_y2.z+=fmod_cbp_y2.y;\n"\r
  96                 "  fmod_cbp_y2.w+=fmod_cbp_y2.z;\n"\r
  97                 "  fmod_cbp_uv2.x+=fmod_cbp_y2.w;\n"\r
  98                 "  fmod_cbp_uv2.y+=fmod_cbp_uv2.x;\n"*/\r
  99 \r
 100 \r
 101                 "  float tcbp=cbp;\n"\r
 102                 "  float tpos=czero;\n"\r
 103                 "  vec4 fmod_cbp_y=vec4(czero,czero,czero,czero);\n"\r
 104                 "  vec2 fmod_cbp_uv=vec2(czero,czero);\n"\r
 105                 "  vec4 fmod_cbp_y2=vec4(czero,czero,czero,czero);\n"\r
 106                 "  vec2 fmod_cbp_uv2=vec2(czero,czero);\n"\r
 107                 "  if (tcbp>=uv_cbp.y){\n"\r
 108                 "    fmod_cbp_y.x=one;\n"\r
 109                 "    fmod_cbp_y2.x=tpos;\n"\r
 110                 "    tpos++;\n"\r
 111                 "    tcbp-=uv_cbp.y;\n"\r
 112                 "  }\n"\r
 113                 "  if (tcbp>=uv_cbp.x){\n"\r
 114                 "    fmod_cbp_y.y=one;\n"\r
 115                 "    fmod_cbp_y2.y=tpos;\n"\r
 116                 "    tpos++;\n"\r
 117                 "    tcbp-=uv_cbp.x;\n"\r
 118                 "  }\n"\r
 119                 "  if (tcbp>=y_cbp.w){\n"\r
 120                 "    fmod_cbp_y.z=one;\n"\r
 121                 "    fmod_cbp_y2.z=tpos;\n"\r
 122                 "    tpos++;\n"\r
 123                 "    tcbp-=y_cbp.w;\n"\r
 124                 "  }\n"\r
 125                 "  if (tcbp>=y_cbp.z){\n"\r
 126                 "    fmod_cbp_y.w=one;\n"\r
 127                 "    fmod_cbp_y2.w=tpos;\n"\r
 128                 "    tpos++;\n"\r
 129                 "    tcbp-=y_cbp.z;\n"\r
 130                 "  }\n"\r
 131                 "  if (tcbp>=y_cbp.y){\n"\r
 132                 "    fmod_cbp_uv.x=one;\n"\r
 133                 "    fmod_cbp_uv2.x=tpos;\n"\r
 134                 "    tpos++;\n"\r
 135                 "    tcbp-=y_cbp.y;\n"\r
 136                 "  }\n"\r
 137                 "  if (tcbp>=y_cbp.x){\n"\r
 138                 "    fmod_cbp_uv.y=one;\n"\r
 139                 "    fmod_cbp_uv2.y=tpos;\n"\r
 140         //      "    tpos++;\n"\r
 141         //      "    tcbp-=y_cbp.y;\n"\r
 142                 "  }\n"\r
 143 \r
 144 \r
 145 \r
 146 \r
 147 \r
 148 \r
 149 \r
 150 \r
 151                 // now calculate their position inside the short array\r
 152                 "  float m_index=index.x/*+index.y*c65536*/;\n" //Not Endian save\r
 153                 "  fmod_cbp_y2+=m_index;\n" //shift to the blocks\r
 154                 "  fmod_cbp_uv2+=m_index;\n"\r
 155 \r
 156                 "  out_yblockpos_y=floor((fmod_cbp_y2)*c1over32);\n"\r
 157                 "  out_uvblockpos_xy.zw=floor((fmod_cbp_uv2)*c1over32);\n"\r
 158                 "  out_yblockpos_x=fmod_cbp_y2-c32*out_yblockpos_y;\n"\r
 159             "  out_uvblockpos_xy.xy=fmod_cbp_uv2-c32*out_uvblockpos_xy.zw;\n"\r
 160 \r
 161 \r
 162 \r
 163                 //Kick out uncoded blocks\r
 164         //      "  out_yblockpos_y-=sign(fmod_cbp_y-one)*c1024;\n"\r
 165         //      "  out_uvblockpos_xy.zw-=sign(fmod_cbp_uv-one)*c1024;\n"\r
 166 \r
 167                 "  out_yblockpos_y=mix(vec4(c1024,c1024,c1024,c1024),out_yblockpos_y,fmod_cbp_y);\n"\r
 168                 "  out_uvblockpos_xy.zw=mix(vec2(c1024,c1024),out_uvblockpos_xy.zw,fmod_cbp_uv);\n"\r
 169 \r
 170 \r
 171                 // set start positions\r
 172         //      "  vec4 motion_vertical=vec4(block_types.z,block_types.z,block_types.z,block_types.z);\n"\r
 173         //      "  vec4 mod_motion_vertical=mod(motion_vertical,vec4(y_cbp.yzw,uv_cbp.x));\n"\r
 174         //      "  mod_motion_vertical=vec4(lessThanEqual(y_cbp,mod_motion_vertical));\n"\r
 175 \r
 176                 "  out_moco_pos.xy=(block_pos.xy+block_edge.xy)*uv_cbp.x/*16*/+one;"\r
 177                 "  out_unsupported=czero;\n"\r
 178                 "  out_moco_pos.zw=vec2(czero,czero);\n"\r
 179                 "  out_misc_info.y=one;\n" // this is the y step\r
 180                 "  if (block_types.x<uv_cbp.x /* 16*/) {\n" // not intra coded\r
 181                 "         float forward_backward=mod(block_types.x,y_cbp.w /* 8*/);\n"\r
 182                 "     out_moco_pos.zw=vec2(one,czero);\n"\r
 183                 "     if (forward_backward>y_cbp.z /* 4*/) {\n"\r
 184                 "         out_moco_pos.zw=vec2(chalf,chalf);\n"\r
 185                 //"          out_unsupported=2.;\n"\r
 186                 "     } else if (forward_backward>y_cbp.y /* 2*/ ) {\n" //backward\r
 187                 "         out_moco_pos.zw=vec2(czero,one);\n"\r
 188                 //"          out_unsupported=2.;\n"\r
 189                 "     } else {\n" //forward\r
 190                 "         out_moco_pos.zw=vec2(one,czero);\n"\r
 191                 "     } \n"\r
 192                 "     if ((out_moco_pos.w+out_moco_pos.z)>y_cbp.x) {"\r
 193                 "         out_moco_pos.zw*=chalf;\n"\r
 194                 "     }\n"\r
 195                 "     if (block_types.y==y_cbp.y /*2*/) {" //Frame\r
 196                 "        out_moco_forward=vec4(PMV1.xy,PMV1.xy);\n"\r
 197                 "        out_moco_backward=vec4(PMV1.zw,PMV1.zw);\n"\r
 198                 //"          out_unsupported=2.;\n"\r
 199                 "     } else if (block_types.y==y_cbp.x /*1*/) {" //Field\r
 200                 "        out_moco_forward=vec4(PMV1.xy,PMV2.xy);\n"\r
 201                 "        out_moco_backward=vec4(PMV1.zw,PMV2.zw);\n"\r
 202 \r
 203                 "        float motion_vert=block_types.z;\n"\r
 204                 "        out_moco_forward.w-=one;\n"\r
 205                 "        out_moco_backward.w-=one;\n"\r
 206                 "        if (motion_vert>= y_cbp.w) {\n" //second_backward\r
 207                 "            motion_vert-=y_cbp.w;\n"\r
 208                 "            out_moco_backward.w+=one;\n"\r
 209                 "         }\n"\r
 210                 "        if (motion_vert>= y_cbp.z) {\n" //second_forward\r
 211                 "            motion_vert-=y_cbp.z;\n"\r
 212                 "            out_moco_forward.w+=one;\n"\r
 213                 "         }\n"\r
 214                 "        if (motion_vert>= y_cbp.y) {\n" //first_backward\r
 215                 "            motion_vert-=y_cbp.y;\n"\r
 216                 "            out_moco_backward.y+=one;\n"\r
 217                 "         }\n"\r
 218                 "        if (motion_vert>= y_cbp.x) {\n" //second_forward\r
 219                 //"            motion_vert-=y_cbp.z;\n"\r
 220                 "            out_moco_forward.y+=one;\n"\r
 221                 "         }\n"\r
 222         /*      "        out_moco_forward.y+=mod_motion_vertical.x;\n"\r
 223                 "        out_moco_backward.y+=mod_motion_vertical.y;\n"\r
 224                 "        out_moco_forward.w-=one-mod_motion_vertical.z;\n"\r
 225                 "        out_moco_backward.w-=one-mod_motion_vertical.w;\n"*/\r
 226                 "         out_misc_info.y=one;\n" // step to for field based\r
 227         //      "            out_unsupported=2.;\n"\r
 228                 "     } else {\n"\r
 229                 "            out_unsupported=1.;\n"\r
 230                 "     }\n"\r
 231                 "  }\n"\r
 232         //      "   if (cbp==63. || cbp==0.) out_unsupported=2.;\n"\r
 233         //      "   if (fmod_cbp_y.w==1. && mod(cbp,8.)>=4.) out_unsupported=2.;\n"\r
 234 \r
 235 \r
 236 \r
 237 \r
 238                 "  out_block_edge=block_edge;\n"\r
 239                 "  out_misc_info.x=block_types.w;\n"\r
 240                 "  vec4 out_pos=block_pos;\n"\r
 241                 "  out_pos.xy+=block_edge;\n"\r
 242                 "  out_pos.xy*=pict_scale;\n"\r
 243                 "  out_pos.xy-=vec2(one,one);"\r
 244                 "  out_pos.zw=vec2(one,one);"\r
 245                 " gl_Position=out_pos;\n"\r
 246                 "}\n";\r
 247 \r
 248 const GLchar moco_frag_shader[] =\r
 249                 "precision mediump float;\n"\r
 250                 "uniform sampler2D blocks;\n"\r
 251                 "uniform sampler2D forward_pic;\n"\r
 252                 "uniform sampler2D backward_pic;\n"\r
 253                 "uniform vec2 pict_size;\n"\r
 254                 "varying vec4 out_yblockpos_x;\n"\r
 255                 "varying vec4 out_yblockpos_y;\n"\r
 256                 "varying vec4 out_uvblockpos_xy;\n"\r
 257                 "varying vec2 out_block_edge;\n"\r
 258                 "varying vec4 out_misc_info;\n"// misc info x= DCT info, y= field based offsets\r
 259                 "varying float out_unsupported;\n"\r
 260                 "varying vec4 out_moco_forward;\n"\r
 261                 "varying vec4 out_moco_backward;\n"\r
 262                 "varying vec4 out_moco_pos;\n"\r
 263 \r
 264                 "const float halfst=0.5;\n"\r
 265                 "const float ctwo=2.0;\n"\r
 266                 "const float cone=1.0;\n"\r
 267                 "const float czero=0.0;\n"\r
 268                 "const float sieben=7.0;\n"\r
 269                 "const float acht=8.0;\n"\r
 270                 "const float s8=1./8.;\n"\r
 271                 "const float s16=1./16.;\n"\r
 272                 "const float c1over2048=1./2048.;\n"\r
 273                 "const float c1over1024=1./1024.;\n"\r
 274                 "const float c255=255.;\n"\r
 275                 "const float c1over255=1./255.;\n"\r
 276                 "const float c65280=65280.;\n"\r
 277                 "const float c65536=65536.;\n"\r
 278                 "const float cstep=32767.;\n"\r
 279                 "\n"\r
 280                 "float unpack_short(vec2 income) {\n"\r
 281                 "   float temp=income.y*c65280+income.x*c255;\n"\r
 282                 "   temp-=step(cstep,temp)*c65536;\n"\r
 283                 "   return temp*c1over255;\n"\r
 284                 "}"\r
 285                 "vec2 unpack_short2(vec4 income) {\n"\r
 286                 "   vec2 temp=income.yw*c65280+income.xz*c255;\n"\r
 287                 "   temp-=step(cstep,temp)*c65536;\n"\r
 288                 "   return temp*c1over255;\n"\r
 289                 "}"\r
 290         //      "uniform sampler2D textureV;\n"\r
 291         //      "uniform sampler2D textureY;\n"\r
 292 //              "varying vec2 out_texCoord;\n"\r
 293                 "void main()\n"\r
 294                 "{\n"\r
 295                 // first figure out the block num for y, first decide between up and down, fix me field\r
 296         //non field code\r
 297                 " vec4 ypos_temp1;\n"\r
 298                 " vec4 our_fragcol=vec4(czero,czero,czero,cone);\n"\r
 299                 " bool upper_half;\n"\r
 300                 " float line_step;\n"\r
 301                 " if (out_misc_info.x!=0.) {\n" //test the dct type\r
 302                 "  upper_half=mod(floor(out_block_edge.y*acht),ctwo)==cone;\n"\r
 303                 "  line_step=cone;\n"\r
 304                 "}else{\n"\r
 305                 "  upper_half=halfst<out_block_edge.y;\n"\r
 306                 "  line_step=ctwo;\n"\r
 307                 "}\n"\r
 308                 " if (upper_half) {\n"\r
 309                 "    ypos_temp1=vec4(out_yblockpos_x.z,out_yblockpos_y.z,out_yblockpos_x.w,out_yblockpos_y.w);\n"\r
 310                 "  } else {\n"\r
 311                 "    ypos_temp1=vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y);\n"\r
 312                 " }\n"\r
 313     //  " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"\r
 314         //      "                  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
 315                 //field code\r
 316         //      " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"\r
 317         //                      "                  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
 318 \r
 319                 //decide between left and right\r
 320                 " vec4 ypos_temp2;\n"\r
 321                 "if (halfst<out_block_edge.x){\n"\r
 322                 "  ypos_temp2.xy=ypos_temp1.zw;\n"\r
 323                 " }else {\n"\r
 324                 "  ypos_temp2.xy=ypos_temp1.xy;\n"\r
 325                 " }\n"\r
 326                 //now get the intra 8x8 Block coordinates\r
 327                 " vec4 ypos_temp3;\n"\r
 328                 " ypos_temp3.xy=floor(mod(out_block_edge*vec2(ctwo,line_step),cone)*acht);\n"\r
 329                 " ypos_temp2.x=(ypos_temp3.x+(ypos_temp3.y+acht*(ypos_temp2.x))*acht);\n"\r
 330                 //" bool subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"\r
 331                 " bool subsample=mod(ypos_temp3.x,ctwo)==cone;\n"\r
 332                 " ypos_temp2.x*=halfst;\n"\r
 333                 " ypos_temp2.xy*=c1over1024;\n"\r
 334                 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data\r
 335                 "if (subsample){\n"\r
 336                 "  ypos_temp3.xy=ypos_temp1.zw;\n"\r
 337                 //"  ypos_temp2=vec2(cone,0.);\n"\r
 338                 " }else {\n"\r
 339                 "  ypos_temp3.xy=ypos_temp1.xy;\n"\r
 340                 " }\n"\r
 341                 " our_fragcol.r=unpack_short(ypos_temp3.xy);\n"\r
 342 \r
 343                 //now uv\r
 344         /*      " ypos_temp3=floor(out_block_edge*acht);\n"\r
 345                 " ypos_temp2.yw=floor(out_uvblockpos_xy.zw);\n"\r
 346                 " ypos_temp2.xz=(ypos_temp3.x+(ypos_temp3.y+acht*(out_uvblockpos_xy.xy))*acht);\n"\r
 347                 //" subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"\r
 348                 " subsample=mod(ypos_temp3.x,ctwo)==cone;\n"\r
 349                 " ypos_temp2.xz*=halfst;\n"\r
 350                 " ypos_temp2*=c1over1024;\n"\r
 351 \r
 352                 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data\r
 353                 " if (subsample){\n"\r
 354                 "  ypos_temp3.xy=ypos_temp1.zw;\n"\r
 355                 " }else {\n"\r
 356                 "  ypos_temp3.xy=ypos_temp1.xy;\n"\r
 357                 " }\n"\r
 358                 " our_fragcol.g=unpack_short(ypos_temp3.xy);\n"\r
 359 \r
 360                 " ypos_temp1=texture2D(blocks,ypos_temp2.zw);\n" // now select the right data\r
 361                 " if (subsample){\n"\r
 362                 "  ypos_temp3.xy=ypos_temp1.zw;\n"\r
 363                 " }else {\n"\r
 364                 "  ypos_temp3.xy=ypos_temp1.xy;\n"\r
 365                 " }\n"\r
 366                 " our_fragcol.b=unpack_short(ypos_temp3.rg);\n"*/\r
 367                 " ypos_temp3.xy=floor(out_block_edge*acht);\n"\r
 368                 " ypos_temp2.yw=floor(out_uvblockpos_xy.zw);\n"\r
 369                 " ypos_temp2.xz=(ypos_temp3.x+(ypos_temp3.y+acht*(out_uvblockpos_xy.xy))*acht);\n"\r
 370                 //" subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"\r
 371                 " subsample=mod(ypos_temp3.x,ctwo)==cone;\n"\r
 372                 " ypos_temp2.xz*=halfst;\n"\r
 373                 " ypos_temp2*=c1over1024;\n"\r
 374 \r
 375                 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data//82\r
 376                 " ypos_temp3=texture2D(blocks,ypos_temp2.zw);\n" // now select the right data\r
 377         //      " if (subsample){\n"\r
 378                 //"  ypos_temp3.zw=ypos_temp3.zw;\n"\r
 379                 //"  ypos_temp3.xy=ypos_temp1.zw;\n"\r
 380                 //"  ypos_temp3=vec4(ypos_temp1.zw,ypos_temp3.zw);\n"\r
 381 \r
 382         //      " }else {\n"\r
 383                 "  ypos_temp3=vec4(ypos_temp1.xy,ypos_temp3.xy);\n"\r
 384         //      " }\n"\r
 385                 " our_fragcol.gb=unpack_short2(ypos_temp3);\n"\r
 386                 //" our_fragcol.g=unpack_short(ypos_temp3.xy);\n"\r
 387                 //" our_fragcol.b=unpack_short(ypos_temp3.zw);\n"\r
 388 \r
 389 \r
 390         /*      " if (subsample){\n"\r
 391                 "  ypos_temp3.xy=ypos_temp1.zw;\n"\r
 392                 " }else {\n"\r
 393                 "  ypos_temp3.xy=ypos_temp1.xy;\n"\r
 394                 " }\n"\r
 395                 " our_fragcol.b=unpack_short(ypos_temp3.rg);\n"*/\r
 396 \r
 397                 //MOCO\r
 398                 // decide if it is top or bottom\r
 399                 " vec4 moco_work;\n"\r
 400                 " if (mod(floor(out_moco_pos.y),ctwo)!=cone) {\n"\r
 401                 "      moco_work=vec4(out_moco_forward.xy,out_moco_backward.xy);\n"\r
 402                 "} else {\n"\r
 403                 "      moco_work=vec4(out_moco_forward.zw,out_moco_backward.zw);\n"\r
 404                 "}\n"\r
 405                 // now we handle the y fetching\r
 406                 " vec4 moco_temp1;\n"\r
 407                 " vec4 moco_temp2;\n"\r
 408                 " vec4 subpixel1=floor(mod(moco_work,ctwo))*halfst; \n"\r
 409                 " vec4 subpixel2=floor(mod(moco_work*halfst,ctwo))*halfst; \n"\r
 410                 " moco_temp1=floor(moco_work*halfst)+floor(vec4(out_moco_pos.xy,out_moco_pos.xy));\n"\r
 411                 " moco_temp2=(floor(moco_work*halfst*halfst)+floor(vec4(out_moco_pos.xy,out_moco_pos.xy)*halfst))*ctwo;\n"\r
 412                 " vec4 c00,c01,c10,c11;\n"\r
 413 \r
 414                 " c00.r=texture2D(forward_pic,moco_temp1.xy*pict_size).r;\n"\r
 415                 " c01.r=texture2D(forward_pic,(moco_temp1.xy+vec2(czero,out_misc_info.y))*pict_size).r;\n"\r
 416                 " c10.r=texture2D(forward_pic,(moco_temp1.xy+vec2(cone,czero))*pict_size).r;\n"\r
 417                 " c11.r=texture2D(forward_pic,(moco_temp1.xy+vec2(cone,out_misc_info.y))*pict_size).r;\n"\r
 418                 " c00.gb=texture2D(forward_pic,moco_temp2.xy*pict_size).gb;\n"\r
 419                 " c01.gb=texture2D(forward_pic,(moco_temp2.xy+vec2(czero,ctwo*out_misc_info.y))*pict_size).gb;\n"\r
 420                 " c10.gb=texture2D(forward_pic,(moco_temp2.xy+vec2(ctwo,czero))*pict_size).gb;\n"//106\r
 421                 " c11.gb=texture2D(forward_pic,(moco_temp2.xy+vec2(ctwo,ctwo*out_misc_info.y))*pict_size).gb;\n"\r
 422                 " vec3 tmp_sub1=vec3(subpixel1.x,subpixel2.xx);"\r
 423                 " vec3 tmp_sub2=vec3(subpixel1.y,subpixel2.yy);"\r
 424                 " our_fragcol.rgb+=mix(mix(c00.rgb,c10.rgb,tmp_sub1),mix(c01.rgb,c11.rgb,tmp_sub1),tmp_sub2)*out_moco_pos.z;\n"\r
 425 \r
 426         //      " our_fragcol.r+=mix(mix(c00.r,c10.r,subpixel1.x),mix(c01.r,c11.r,subpixel1.x),subpixel1.y)*out_moco_pos.z;\n"\r
 427 \r
 428 \r
 429         //      " our_fragcol.gb+=mix(mix(c00.gb,c10.gb,subpixel2.x),mix(c01.gb,c11.gb,subpixel2.x),subpixel2.y)*out_moco_pos.z;\n"\r
 430 \r
 431 \r
 432                 " c00.r=texture2D(backward_pic,moco_temp1.zw*pict_size).r;\n"//backward\r
 433                 " c01.r=texture2D(backward_pic,(moco_temp1.zw+vec2(czero,out_misc_info.y))*pict_size).r;\n"\r
 434                 " c10.r=texture2D(backward_pic,(moco_temp1.zw+vec2(cone,czero))*pict_size).r;\n"\r
 435                 " c11.r=texture2D(backward_pic,(moco_temp1.zw+vec2(cone,out_misc_info.y))*pict_size).r;\n"\r
 436                 " c00.gb=texture2D(backward_pic,moco_temp2.zw*pict_size).gb;\n"\r
 437                 " c01.gb=texture2D(backward_pic,(moco_temp2.zw+vec2(czero,ctwo*out_misc_info.y))*pict_size).gb;\n"\r
 438                 " c10.gb=texture2D(backward_pic,(moco_temp2.zw+vec2(ctwo,czero))*pict_size).gb;\n"\r
 439                 " c11.gb=texture2D(backward_pic,(moco_temp2.zw+vec2(ctwo,ctwo*out_misc_info.y))*pict_size).gb;\n"\r
 440 \r
 441                 " tmp_sub1=vec3(subpixel1.z,subpixel2.zz);"\r
 442                 " tmp_sub2=vec3(subpixel1.w,subpixel2.ww);"\r
 443                 " our_fragcol.rgb+=mix(mix(c00.rgb,c10.rgb,tmp_sub1),mix(c01.rgb,c11.rgb,tmp_sub1),tmp_sub2)*out_moco_pos.w;\n"\r
 444 \r
 445                 //" our_fragcol.r+=mix(mix(c00.r,c10.r,subpixel1.z),mix(c01.r,c11.r,subpixel1.z),subpixel1.w)*out_moco_pos.w;\n"\r
 446                 // now handle UV\r
 447 \r
 448 \r
 449                 //" our_fragcol.gb+=mix(mix(c00.gb,c10.gb,subpixel2.z),mix(c01.gb,c11.gb,subpixel2.z),subpixel2.w)*out_moco_pos.w;\n"\r
 450 \r
 451                 "  gl_FragColor.rgb=our_fragcol.rgb;\n"\r
 452         //      "  gl_FragColor.rgb=vec3(our_fragcol.r,halfst,halfst);\n"\r
 453 //              " if (out_unsupported==1.) {\n"\r
 454 //              "    gl_FragColor.gb=vec2(cone,0.0);\n"\r
 455 //              "}else if (out_unsupported==2.) {\n"\r
 456 //              "    gl_FragColor.gb=vec2(0.0,cone);\n"\r
 457 //              "}\n"\r
 458 \r
 459 \r
 460                 //" ypos_temp2=mix(ypos_temp1.rg,ypos_temp1.ba,step(c1over2047,mod(ypos_temp2.x,c1over1023)));\n" //activate this\r
 461 \r
 462 \r
 463                 //" gl_FragColor.r=subsample/acht;\n" //signed later TODO\r
 464                 //" gl_FragColor.g=0.5;\n"\r
 465                 //" gl_FragColor.b=0.5;\n"\r
 466                 " gl_FragColor.a=1.0;\n"\r
 467                 //" vec4 blocks=texture2D(blocks,gl_FragCoord.xy/600.);\n"\r
 468 //              "help.x=texture2D(textureY,out_texCoord).r;\n"\r
 469 //              "help.y=texture2D(textureU,out_texCoord).r;\n"\r
 470 //              "help.z=texture2D(textureV,out_texCoord).r;\n" //-uv_corr;\n"\r
 471    //   "  gl_FragColor.rgba=blocks;\n"\r
 472         //      "  gl_FragColor.rgba=vec4(0.7,0.5,0.5,1.0);\n"\r
 473                 //"  gl_FragColor.a=1.;\n"\r
 474                 "}\n";\r
 475 \r
 476 GLMocoShader::GLMocoShader(): GLShader("GLMocoShader")\r
 477 {\r
 478 \r
 479         frame_buf=0;\r
 480         blocks_loc=0;\r
 481 }\r
 482 \r
 483 GLMocoShader::~GLMocoShader()\r
 484 {\r
 485         //parent does everything\r
 486 }\r
 487 \r
 488 int GLMocoShader::init() {\r
 489 \r
 490         if (!initShaders(moco_vertex_shader, moco_frag_shader)) {\r
 491                 Log::getInstance()->log("GLMocoShader", Log::ERR, "init Shaders failed for GLMocoShader");\r
 492                 return 0;\r
 493         }\r
 494         loc_pict_scale = glGetUniformLocation(shad_program, "pict_scale");\r
 495         blocks_loc = glGetUniformLocation(shad_program, "blocks");\r
 496         forward_pic_loc = glGetUniformLocation(shad_program, "forward_pic");\r
 497         backward_pic_loc = glGetUniformLocation(shad_program, "backward_pic");\r
 498     pict_size_loc = glGetUniformLocation(shad_program, "pict_size");\r
 499 \r
 500 //      frame_sampler_locY = glGetUniformLocation(shad_program, "textureY");\r
 501         // Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locY,glGetError());\r
 502 //      frame_sampler_locU = glGetUniformLocation(shad_program, "textureU");\r
 503         //Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locU,glGetError());\r
 504 //      frame_sampler_locV = glGetUniformLocation(shad_program, "textureV");\r
 505         glGenFramebuffers(1, &frame_buf);\r
 506         //Log::getInstance()->log("GLMocoShader", Log::WARN, "genframe bufmark1 glerror %x",glGetError());\r
 507         glGenTextures(1, &data_blocks);\r
 508         glBindTexture(GL_TEXTURE_2D, data_blocks);\r
 509         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, BLOCK_TEXTURE_WIDTH >>1, BLOCK_TEXTURE_HEIGHT, 0, GL_RGBA,\r
 510                                 GL_UNSIGNED_BYTE, NULL);\r
 511         char buffer[BLOCK_TEXTURE_WIDTH*2];\r
 512         memset(buffer,0,BLOCK_TEXTURE_WIDTH*2); // the last line is black, simplifies the shader algorithms\r
 513 \r
 514         glTexSubImage2D(GL_TEXTURE_2D,0,0,BLOCK_TEXTURE_HEIGHT-1,\r
 515                         BLOCK_TEXTURE_WIDTH>>1,1,\r
 516                         GL_RGBA,GL_UNSIGNED_BYTE,\r
 517                         buffer);\r
 518 \r
 519         glGenBuffers(1,&macro_block);\r
 520         glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 521         glBufferData(GL_ARRAY_BUFFER,4096*4*sizeof(XvMCMacroBlock),NULL,GL_DYNAMIC_DRAW);\r
 522         valid_macro_blocks=0;\r
 523 \r
 524 \r
 525         glGenBuffers(1,&triangles);\r
 526         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);\r
 527         GLushort *tri_indices=(GLushort *)malloc(sizeof(GLushort)*4096*6);\r
 528         if (!tri_indices) {\r
 529                 Log::getInstance()->log("GLMocoShader", Log::WARN, "allocating triindices failed");\r
 530                 return 0;\r
 531         }\r
 532         GLushort *tri_indices_run=tri_indices;\r
 533         for (int i=0;i<4096;i++) {\r
 534                 *tri_indices_run=i+0*4096;  //strip\r
 535                 tri_indices_run++;\r
 536                 *tri_indices_run=i+2*4096;  //strip\r
 537                 tri_indices_run++;\r
 538                 *tri_indices_run=i+1*4096;  //strip\r
 539                 tri_indices_run++;\r
 540                 *tri_indices_run=i+3*4096;  //strip\r
 541                 tri_indices_run++;\r
 542                 *tri_indices_run=i+3*4096;  //strip\r
 543                 tri_indices_run++;\r
 544                 *tri_indices_run=i+1+0*4096;  //strip\r
 545                 tri_indices_run++;\r
 546         }\r
 547 \r
 548 \r
 549 \r
 550 \r
 551 \r
 552         glBufferData(GL_ELEMENT_ARRAY_BUFFER,4096*6*sizeof(GLushort),tri_indices,GL_STREAM_DRAW);\r
 553         free(tri_indices);\r
 554 \r
 555         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);\r
 556         glBindBuffer(GL_ARRAY_BUFFER,0);\r
 557 \r
 558 \r
 559 \r
 560         return 1;\r
 561 \r
 562 }\r
 563 \r
 564 int GLMocoShader::deinit()\r
 565 {\r
 566         glDeleteFramebuffers(1, &frame_buf);\r
 567         glDeleteTextures(1, &data_blocks);\r
 568         return deinitShaders();\r
 569 }\r
 570 \r
 571 \r
 572 \r
 573 int GLMocoShader::uploadDataBlocks(short* blocks,unsigned int num_blocks, XvMCMacroBlock *m_blocks,unsigned int num_m_blocks)\r
 574 {\r
 575         unsigned int height=(num_blocks)/(BLOCK_PER_ROW);\r
 576 \r
 577         glBindTexture(GL_TEXTURE_2D, data_blocks);\r
 578         glPixelStorei(GL_UNPACK_ALIGNMENT,1);\r
 579 \r
 580 \r
 581 \r
 582 \r
 583         Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark1 %d %d %d",height,num_blocks,num_m_blocks);\r
 584         glTexSubImage2D(GL_TEXTURE_2D,0,0,0,\r
 585                 BLOCK_TEXTURE_WIDTH>>1,height,\r
 586                 GL_RGBA,GL_UNSIGNED_BYTE,\r
 587                 blocks);\r
 588 //      Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
 589         glTexSubImage2D(GL_TEXTURE_2D,0,0,height,\r
 590                         ((num_blocks%BLOCK_PER_ROW)>>1)*BLOCK_SIZE,1,\r
 591                         GL_RGBA,GL_UNSIGNED_BYTE,\r
 592                         blocks+height*BLOCK_PER_ROW*BLOCK_SIZE);\r
 593 \r
 594         //Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());\r
 595 \r
 596 \r
 597 \r
 598         glBindTexture(GL_TEXTURE_2D, 0);\r
 599 \r
 600         valid_macro_blocks=num_m_blocks;\r
 601         glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 602         XvMCMacroBlock *m_blocks_run=m_blocks;\r
 603         XvMCMacroBlock *m_blocks_end=m_blocks+num_m_blocks;\r
 604         while (m_blocks_run!=m_blocks_end) {\r
 605                 m_blocks_run->pad0=0xFF00;\r
 606         //      Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks coded block %x %x %d",\r
 607         //                      m_blocks_run->coded_block_pattern, m_blocks_run->macroblock_type,m_blocks_run->index);\r
 608                 m_blocks_run++;\r
 609 \r
 610         }\r
 611         // debug\r
 612 /*      m_blocks[0].x=0;\r
 613         m_blocks[0].y=0;\r
 614         m_blocks[3]=m_blocks[2]=m_blocks[1]=m_blocks[0];\r
 615         m_blocks[0].pad0=0xFF00;\r
 616         m_blocks[1].pad0=0xFFFF;\r
 617         m_blocks[2].pad0=0x0000;\r
 618         m_blocks[3].pad0=0x00FF;\r
 619         m_blocks[1].x=0;\r
 620         m_blocks[1].y=0;\r
 621         m_blocks[2].x=0;\r
 622         m_blocks[2].y=0;\r
 623         m_blocks[3].x=0;\r
 624         m_blocks[3].y=0;*/\r
 625 \r
 626         glBufferSubData(GL_ARRAY_BUFFER, 0* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),\r
 627                         m_blocks);\r
 628 \r
 629 \r
 630         m_blocks_run = m_blocks;\r
 631         m_blocks_end = m_blocks + num_m_blocks;\r
 632         while (m_blocks_run != m_blocks_end) {\r
 633                 m_blocks_run->pad0 = 0xFFFF;\r
 634                 m_blocks_run++;\r
 635         }\r
 636         glBufferSubData(GL_ARRAY_BUFFER, 4096* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),\r
 637                         m_blocks);\r
 638 \r
 639 \r
 640         m_blocks_run = m_blocks;\r
 641         m_blocks_end = m_blocks + num_m_blocks;\r
 642         while (m_blocks_run != m_blocks_end) {\r
 643                 m_blocks_run->pad0 = 0x0000;\r
 644                 m_blocks_run++;\r
 645         }\r
 646         glBufferSubData(GL_ARRAY_BUFFER, 2 * 4096* sizeof(XvMCMacroBlock),\r
 647                         num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);\r
 648 \r
 649 \r
 650         m_blocks_run = m_blocks;\r
 651         m_blocks_end = m_blocks + num_m_blocks;\r
 652         while (m_blocks_run != m_blocks_end) {\r
 653                 m_blocks_run->pad0 = 0x00FF;\r
 654                 m_blocks_run++;\r
 655         }\r
 656         glBufferSubData(GL_ARRAY_BUFFER, 3 * 4096* sizeof(XvMCMacroBlock),\r
 657                         num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);\r
 658 \r
 659 \r
 660         glBindBuffer(GL_ARRAY_BUFFER,0);\r
 661 \r
 662         return 1;\r
 663 \r
 664 \r
 665 \r
 666 }\r
 667 \r
 668 int GLMocoShader::doMoCo(VPEOGLFrame *target,VPEOGLFrame *forward,VPEOGLFrame *backward)\r
 669 {\r
 670 \r
 671 //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-2 glerror %x %x",glGetError(),frame_buf);\r
 672 \r
 673         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-1 glerror %x %x",glGetError(),frame_buf);\r
 674         glBindFramebuffer(GL_FRAMEBUFFER, frame_buf);\r
 675         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1 glerror %x %x %x",glGetError(),target->textures[0],target->textures[1]);\r
 676 \r
 677 \r
 678         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,\r
 679                         GL_TEXTURE_2D, target->textures[0], 0);\r
 680         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1apres glerror %x",glGetError());\r
 681 \r
 682 \r
 683 \r
 684 \r
 685 \r
 686         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2 glerror %x",glGetError());\r
 687 \r
 688         //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2a glerror %x",glGetError());\r
 689 \r
 690         int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);\r
 691         if (status == GL_FRAMEBUFFER_COMPLETE) {\r
 692                 glViewport(0, 0, target->width,target->height);\r
 693         //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2b glerror %x",glGetError());\r
 694 \r
 695                 XvMCMacroBlock * helperp=NULL;\r
 696 \r
 697                 glClearColor(0.0f,0.5f,0.5f,1.f); //this black\r
 698                 glClear(GL_COLOR_BUFFER_BIT);\r
 699                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2c glerror %x",glGetError());\r
 700 \r
 701                 glUseProgram(shad_program);\r
 702                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
 703 \r
 704 \r
 705                 const GLfloat pict_scale[]={  32./((float)target->width),32./((float)target->height)};\r
 706 \r
 707                 glUniform2fv(loc_pict_scale,1,(const GLfloat*)&pict_scale);\r
 708 \r
 709 \r
 710                 const GLfloat pict_size[]={  1./((float)target->width),1./((float)target->height)};\r
 711                 glUniform2fv(pict_size_loc,1,(const GLfloat*)&pict_size);\r
 712 \r
 713                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);\r
 714                                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());\r
 715                 glBindBuffer(GL_ARRAY_BUFFER,macro_block);\r
 716 \r
 717 \r
 718 \r
 719                 glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,\r
 720                                 sizeof(XvMCMacroBlock), NULL);\r
 721 \r
 722                 glEnableVertexAttribArray(0);\r
 723 \r
 724                 glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));\r
 725                 glEnableVertexAttribArray(1);\r
 726 \r
 727                 glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->macroblock_type));\r
 728                 glEnableVertexAttribArray(2);\r
 729 \r
 730                 glVertexAttribPointer(3, 1, GL_UNSIGNED_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->coded_block_pattern));\r
 731                 glEnableVertexAttribArray(3);\r
 732                 glVertexAttribPointer(4, 2, GL_UNSIGNED_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->index));\r
 733                 glEnableVertexAttribArray(4);\r
 734 \r
 735                 glVertexAttribPointer(5, 4, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->PMV[0][0][0]));\r
 736                 glEnableVertexAttribArray(5);\r
 737 \r
 738                 glVertexAttribPointer(6, 4, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->PMV[1][0][0]));\r
 739                 glEnableVertexAttribArray(6);\r
 740 \r
 741 \r
 742 \r
 743 \r
 744                 glActiveTexture(GL_TEXTURE0);\r
 745                 glBindTexture(GL_TEXTURE_2D,data_blocks);\r
 746                 glUniform1i(blocks_loc,0);\r
 747                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);\r
 748                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);\r
 749                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);\r
 750                 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);\r
 751 \r
 752 \r
 753 \r
 754                 if (forward) {\r
 755                 //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo forward %x",forward->textures[0]);\r
 756                         glActiveTexture(GL_TEXTURE1);\r
 757                         glBindTexture(GL_TEXTURE_2D,forward->textures[0]);\r
 758                         glUniform1i(forward_pic_loc,1);\r
 759                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);\r
 760                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);\r
 761                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);\r
 762                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);\r
 763 \r
 764                 }\r
 765 \r
 766                 if (backward) {\r
 767                         glActiveTexture(GL_TEXTURE2);\r
 768                 //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo backward %x",backward->textures[0]);\r
 769                         glBindTexture(GL_TEXTURE_2D,backward->textures[0]);\r
 770                         glUniform1i(backward_pic_loc,2);\r
 771                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);\r
 772                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);\r
 773                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);\r
 774                         glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);\r
 775 \r
 776                 }\r
 777 \r
 778 \r
 779 \r
 780                 glDrawElements(GL_TRIANGLE_STRIP, valid_macro_blocks*6,\r
 781                                 GL_UNSIGNED_SHORT, NULL);\r
 782 \r
 783 \r
 784                 /*\r
 785                 glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), 0);\r
 786                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
 787                 glEnableVertexAttribArray(0);\r
 788 \r
 789                 glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));\r
 790                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());\r
 791                 glEnableVertexAttribArray(1);*/\r
 792 \r
 793         //      Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark4 glerror %x",glGetError());\r
 794 \r
 795 \r
 796                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark6 glerror %x",glGetError());\r
 797 \r
 798         //      glDrawElements(GL_TRIANGLE_STRIP,/*valid_macro_blocks*/4,GL_UNSIGNED_SHORT,0);\r
 799                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark7 glerror %x %x",glGetError(),valid_macro_blocks);\r
 800                 //cleanup\r
 801 \r
 802                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);\r
 803                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());\r
 804                 glBindBuffer(GL_ARRAY_BUFFER,0);\r
 805 \r
 806                 glBindFramebuffer(GL_FRAMEBUFFER, 0);\r
 807                 glActiveTexture(GL_TEXTURE0);\r
 808                 glBindTexture(GL_TEXTURE_2D, 0);\r
 809                 glActiveTexture(GL_TEXTURE1);\r
 810                 glBindTexture(GL_TEXTURE_2D, 0);\r
 811                 glActiveTexture(GL_TEXTURE2);\r
 812                 glBindTexture(GL_TEXTURE_2D, 0);\r
 813                 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark8 glerror %x",glGetError());\r
 814         } else {\r
 815                 glBindFramebuffer(GL_FRAMEBUFFER, 0);\r
 816                 Log::getInstance()->log("GLMocoShader", Log::WARN, "framebuffer not complete %x",status);\r
 817                 return -1;\r
 818         }\r
 819 \r
 820         glFinish(); // since the main rendering is done in a different thread we have to make sure rendering is finished before passing the texture\r
 821         // call this only in the last stage of rendering the moco frame\r
 822         return 0;\r
 823 \r
 824 \r
 825 \r
 826 }\r
 827 \r
 828 /*\r
 829 \r
 830 int GLMocoShader::PrepareRendering(GLuint y_tex, GLuint u_tex, GLuint v_tex) { // This Function setups the rendering pipeline according to the shaders standards\r
 831 \r
 832         //Log::getInstance()->log("OSD", Log::WARN, "mark1 glerror %x",glGetError());\r
 833 \r
 834 \r
 835         //Log::getInstance()->log("OSD", Log::WARN, "mark2 glerror %x",glGetError());\r
 836 \r
 837 \r
 838         glActiveTexture( GL_TEXTURE2);\r
 839         glBindTexture(GL_TEXTURE_2D, v_tex);\r
 840         glUniform1i(frame_sampler_locV, 2);\r
 841         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
 842         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
 843 \r
 844         glActiveTexture( GL_TEXTURE1);\r
 845         glBindTexture(GL_TEXTURE_2D, u_tex);\r
 846         glUniform1i(frame_sampler_locU, 1);\r
 847         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
 848         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
 849 \r
 850         glActiveTexture( GL_TEXTURE0);\r
 851         glBindTexture(GL_TEXTURE_2D, y_tex);\r
 852         glUniform1i(frame_sampler_locY, 0);\r
 853         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r
 854         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);\r
 855         return 1;\r
 856 \r
 857 }*/\r
 858 \r
 859 int GLMocoShader::BindAttributes()\r
 860 {\r
 861         glBindAttribLocation(shad_program,0,"block_pos");\r
 862         glBindAttribLocation(shad_program,1,"block_edge");\r
 863         glBindAttribLocation(shad_program,2,"block_types");\r
 864         glBindAttribLocation(shad_program,3,"cbp");\r
 865         glBindAttribLocation(shad_program,4,"index");\r
 866         glBindAttribLocation(shad_program,5,"PMV1");\r
 867         glBindAttribLocation(shad_program,6,"PMV2");\r
 868 \r
 869         //glBindAttribLocation(shad_program,1,"tex_coord");\r
 870         return 1;\r
 871 }\r