2 Copyright 2012 Marten Richter
\r
4 This file is part of VOMP.
\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
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
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
20 #include "glmocoshader.h"
\r
21 #include "videovpeogl.h"
\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
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
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
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
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
66 "const float c65536=65536.;\n"
\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
75 " vec4 cbp_vec=vec4(cbp,cbp,cbp,cbp);\n"
\r
78 // " vec4 fmod_cbp_y=mod(cbp_vec,y_cbp);\n"
\r
79 // " vec2 fmod_cbp_uv=mod(cbp_vec.xy,uv_cbp);\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
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
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
100 // now calculate their position inside the short array
\r
101 " float m_index=index.x/*+index.y*c65536*/-one;\n" //Not Endian save
\r
102 " fmod_cbp_y2+=m_index;\n" //shift to the blocks
\r
103 " fmod_cbp_uv2+=m_index;\n"
\r
104 " out_yblockpos_x=(mod(fmod_cbp_y2,c32));\n"
\r
105 " out_uvblockpos_xy.xy=(mod(fmod_cbp_uv2,c32));\n"
\r
106 " out_yblockpos_y=floor((fmod_cbp_y2)/c32);\n"
\r
107 " out_uvblockpos_xy.zw=floor((fmod_cbp_uv2)/c32);\n"
\r
109 " out_yblockpos_y=floor((fmod_cbp_y2)*c1over32);\n"
\r
110 " out_uvblockpos_xy.zw=floor((fmod_cbp_uv2)*c1over32);\n"
\r
111 " out_yblockpos_x=fmod_cbp_y2-c32*out_yblockpos_y;\n"
\r
112 " out_uvblockpos_xy.xy=fmod_cbp_uv2-c32*out_uvblockpos_xy.zw;\n"
\r
116 //Kick out uncoded blocks
\r
117 // " out_yblockpos_y-=sign(fmod_cbp_y-one)*c1024;\n"
\r
118 // " out_uvblockpos_xy.zw-=sign(fmod_cbp_uv-one)*c1024;\n"
\r
120 " out_yblockpos_y=mix(vec4(c1024,c1024,c1024,c1024)-one,out_yblockpos_y,fmod_cbp_y);\n"
\r
121 " out_uvblockpos_xy.zw=mix(vec2(c1024,c1024)-one,out_uvblockpos_xy.zw,fmod_cbp_uv);\n"
\r
124 // set start positions
\r
125 " vec4 motion_vertical=vec4(block_types.z,block_types.z,block_types.z,block_types.z);\n"
\r
126 " vec4 mod_motion_vertical=mod(motion_vertical,y_cbp);\n"
\r
127 " mod_motion_vertical=sign(vec4(mod_motion_vertical.yzw,block_types.z)-mod_motion_vertical);\n"
\r
129 " out_moco_pos.xy=(block_pos.xy+block_edge.xy)*uv_cbp.x/*16*/+one;"
\r
130 " out_unsupported=czero;\n"
\r
131 " out_moco_pos.zw=vec2(czero,czero);\n"
\r
132 " out_misc_info.y=one;\n" // this is the y step
\r
133 " if (block_types.x<uv_cbp.x /* 16*/) {\n" // not intra coded
\r
134 " float forward_backward=mod(block_types.x,y_cbp.w /* 8*/);\n"
\r
135 " out_moco_pos.zw=vec2(one,czero);\n"
\r
136 " if (forward_backward>y_cbp.z /* 4*/) {\n"
\r
137 " out_moco_pos.zw=vec2(chalf,chalf);\n"
\r
138 //" out_unsupported=2.;\n"
\r
139 " } else if (forward_backward>y_cbp.y /* 2*/ ) {\n" //backward
\r
140 " out_moco_pos.zw=vec2(czero,one);\n"
\r
141 //" out_unsupported=2.;\n"
\r
142 " } else {\n" //forward
\r
143 " out_moco_pos.zw=vec2(one,czero);\n"
\r
145 " if ((out_moco_pos.w+out_moco_pos.z)>y_cbp.x) {"
\r
146 " out_moco_pos.zw*=chalf;\n"
\r
148 " if (block_types.y==y_cbp.y /*2*/) {" //Frame
\r
149 " out_moco_forward=vec4(PMV1.xy,PMV1.xy);\n"
\r
150 " out_moco_backward=vec4(PMV1.zw,PMV1.zw);\n"
\r
151 //" out_unsupported=2.;\n"
\r
152 " } else if (block_types.y==y_cbp.x /*1*/) {" //Field
\r
153 " out_moco_forward=vec4(PMV1.xy,PMV1.xy);\n"
\r
154 " out_moco_backward=vec4(PMV1.zw,PMV1.zw);\n"
\r
155 " out_moco_forward.y+=mod_motion_vertical.x;\n"
\r
156 " out_moco_backward.y+=mod_motion_vertical.y;\n"
\r
157 " out_moco_forward.w-=one-mod_motion_vertical.z;\n"
\r
158 " out_moco_backward.w-=one-mod_motion_vertical.w;\n"
\r
159 " out_misc_info.y=one;\n" // step to for field based
\r
160 // " out_unsupported=2.;\n"
\r
162 " out_unsupported=1.;\n"
\r
169 " out_block_edge=block_edge;\n"
\r
170 " out_misc_info.x=block_types.w;\n"
\r
171 " vec4 out_pos=block_pos;\n"
\r
172 " out_pos.xy+=block_edge;\n"
\r
173 " out_pos.xy*=pict_scale;\n"
\r
174 " out_pos.xy-=vec2(one,one);"
\r
175 " out_pos.zw=vec2(one,one);"
\r
176 " gl_Position=out_pos;\n"
\r
179 const GLchar moco_frag_shader[] =
\r
180 "precision mediump float;\n"
\r
181 "uniform sampler2D blocks;\n"
\r
182 "uniform sampler2D forward_pic;\n"
\r
183 "uniform sampler2D backward_pic;\n"
\r
184 "uniform vec2 pict_size;\n"
\r
185 "varying vec4 out_yblockpos_x;\n"
\r
186 "varying vec4 out_yblockpos_y;\n"
\r
187 "varying vec4 out_uvblockpos_xy;\n"
\r
188 "varying vec2 out_block_edge;\n"
\r
189 "varying vec4 out_misc_info;\n"// misc info x= DCT info, y= field based offsets
\r
190 "varying float out_unsupported;\n"
\r
191 "varying vec4 out_moco_forward;\n"
\r
192 "varying vec4 out_moco_backward;\n"
\r
193 "varying vec4 out_moco_pos;\n"
\r
195 "const float halfst=0.5;\n"
\r
196 "const float ctwo=2.0;\n"
\r
197 "const float cone=1.0;\n"
\r
198 "const float czero=0.0;\n"
\r
199 "const float sieben=7.0;\n"
\r
200 "const float acht=8.0;\n"
\r
201 "const float s8=1./8.;\n"
\r
202 "const float s16=1./16.;\n"
\r
203 "const float c1over2048=1./2048.;\n"
\r
204 "const float c1over1024=1./1024.;\n"
\r
205 "const float c255=255.;\n"
\r
206 "const float c65280=65280.;\n"
\r
207 "const float c65536=65536.;\n"
\r
208 "const float cstep=32767.;\n"
\r
210 "float unpack_short(vec2 income) {\n"
\r
211 " float temp=income.y*c65280+income.x*c255;\n"
\r
212 " temp-=step(cstep,temp)*c65536;\n"
\r
213 " return temp/c255;\n"
\r
215 // "uniform sampler2D textureV;\n"
\r
216 // "uniform sampler2D textureY;\n"
\r
217 // "varying vec2 out_texCoord;\n"
\r
220 // first figure out the block num for y, first decide between up and down, fix me field
\r
222 " vec4 ypos_temp1;\n"
\r
223 " vec4 our_fragcol=vec4(czero,czero,czero,cone);\n"
\r
224 " bool upper_half;\n"
\r
225 " float line_step;\n"
\r
226 " if (out_misc_info.x!=0.) {\n" //test the dct type
\r
227 " upper_half=mod(floor(out_block_edge.y*acht),ctwo)==cone;\n"
\r
228 " line_step=cone;\n"
\r
230 " upper_half=halfst<out_block_edge.y;\n"
\r
231 " line_step=ctwo;\n"
\r
233 " if (upper_half) {\n"
\r
234 " ypos_temp1=vec4(out_yblockpos_x.z,out_yblockpos_y.z,out_yblockpos_x.w,out_yblockpos_y.w);\n"
\r
236 " ypos_temp1=vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y);\n"
\r
238 // " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"
\r
239 // " 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
241 // " vec4 ypos_temp1=mix(vec4(out_yblockpos_x.x,out_yblockpos_y.x,out_yblockpos_x.y,out_yblockpos_y.y),"
\r
242 // " 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
244 //decide between left and right
\r
245 " vec4 ypos_temp2;\n"
\r
246 "if (halfst<out_block_edge.x){\n"
\r
247 " ypos_temp2.xy=ypos_temp1.zw;\n"
\r
249 " ypos_temp2.xy=ypos_temp1.xy;\n"
\r
251 //now get the intra 8x8 Block coordinates
\r
252 " vec2 ypos_temp3=floor(mod(out_block_edge*vec2(ctwo,line_step),cone)*acht);\n"
\r
253 " ypos_temp2.x=(ypos_temp3.x+(ypos_temp3.y+acht*(ypos_temp2.x))*acht);\n"
\r
254 //" bool subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"
\r
255 " bool subsample=mod(ypos_temp3.x,ctwo)==cone;\n"
\r
256 " ypos_temp2.x*=halfst;\n"
\r
257 " ypos_temp2.xy*=c1over1024;\n"
\r
258 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data
\r
259 "if (subsample){\n"
\r
260 " ypos_temp2.xy=ypos_temp1.zw;\n"
\r
261 //" ypos_temp2=vec2(cone,0.);\n"
\r
263 " ypos_temp2.xy=ypos_temp1.xy;\n"
\r
265 " our_fragcol.r=unpack_short(ypos_temp2.rg);\n"
\r
268 " ypos_temp3=floor(out_block_edge*acht);\n"
\r
269 " ypos_temp2.yw=floor(out_uvblockpos_xy.zw);\n"
\r
270 " ypos_temp2.xz=(ypos_temp3.x+(ypos_temp3.y+acht*(out_uvblockpos_xy.xy))*acht);\n"
\r
271 //" bool subsample=(mod(ypos_temp2.x,ctwo)>halfst);\n"
\r
272 " subsample=mod(ypos_temp3.x,ctwo)==cone;\n"
\r
273 " ypos_temp2.xz*=halfst;\n"
\r
274 " ypos_temp2*=c1over1024;\n"
\r
276 " ypos_temp1=texture2D(blocks,ypos_temp2.xy);\n" // now select the right data
\r
277 " if (subsample){\n"
\r
278 " ypos_temp2.xy=ypos_temp1.zw;\n"
\r
280 " ypos_temp2.xy=ypos_temp1.xy;\n"
\r
282 " our_fragcol.g=unpack_short(ypos_temp2.rg);\n"
\r
284 " ypos_temp1=texture2D(blocks,ypos_temp2.zw);\n" // now select the right data
\r
285 " if (subsample){\n"
\r
286 " ypos_temp2.xy=ypos_temp1.zw;\n"
\r
288 " ypos_temp2.xy=ypos_temp1.xy;\n"
\r
290 " our_fragcol.b=unpack_short(ypos_temp2.rg);\n"
\r
292 // decide if it is top or bottom
\r
293 " vec4 moco_work;\n"
\r
294 " if (mod(floor(out_moco_pos.y),ctwo)!=cone) {\n"
\r
295 " moco_work=vec4(out_moco_forward.xy,out_moco_backward.xy);\n"
\r
297 " moco_work=vec4(out_moco_forward.zw,out_moco_backward.zw);\n"
\r
299 // now we handle the y fetching
\r
300 " vec4 moco_temp;\n"
\r
301 " vec4 subpixel=floor(mod(moco_work,ctwo))*halfst; \n"
\r
302 " moco_temp=floor(moco_work*halfst)+floor(vec4(out_moco_pos.xy,out_moco_pos.xy));\n"
\r
303 " vec4 c00,c01,c10,c11;\n"
\r
305 " c00=texture2D(forward_pic,moco_temp.xy*pict_size);\n"
\r
306 " c01=texture2D(forward_pic,(moco_temp.xy+vec2(czero,out_misc_info.y))*pict_size);\n"
\r
307 " c10=texture2D(forward_pic,(moco_temp.xy+vec2(cone,czero))*pict_size);\n"
\r
308 " c11=texture2D(forward_pic,(moco_temp.xy+vec2(cone,out_misc_info.y))*pict_size);\n"
\r
309 " our_fragcol.r+=mix(mix(c00.r,c10.r,subpixel.x),mix(c01.r,c11.r,subpixel.x),subpixel.y)*out_moco_pos.z;\n"
\r
312 " c00=texture2D(backward_pic,moco_temp.zw*pict_size);\n"//backward
\r
313 " c01=texture2D(backward_pic,(moco_temp.zw+vec2(czero,out_misc_info.y))*pict_size);\n"
\r
314 " c10=texture2D(backward_pic,(moco_temp.zw+vec2(cone,czero))*pict_size);\n"
\r
315 " c11=texture2D(backward_pic,(moco_temp.zw+vec2(cone,out_misc_info.y))*pict_size);\n"
\r
316 " our_fragcol.r+=mix(mix(c00.r,c10.r,subpixel.z),mix(c01.r,c11.r,subpixel.z),subpixel.w)*out_moco_pos.w;\n"
\r
318 " subpixel=floor(mod(moco_work*halfst,ctwo))*halfst; \n"
\r
319 " moco_temp=(floor(moco_work*halfst*halfst)+floor(vec4(out_moco_pos.xy,out_moco_pos.xy)*halfst))*ctwo;\n"
\r
321 " c00=texture2D(forward_pic,moco_temp.xy*pict_size);\n"
\r
322 " c01=texture2D(forward_pic,(moco_temp.xy+vec2(czero,ctwo*out_misc_info.y))*pict_size);\n"
\r
323 " c10=texture2D(forward_pic,(moco_temp.xy+vec2(ctwo,czero))*pict_size);\n"
\r
324 " c11=texture2D(forward_pic,(moco_temp.xy+vec2(ctwo,ctwo*out_misc_info.y))*pict_size);\n"
\r
325 " our_fragcol.gb+=mix(mix(c00.gb,c10.gb,subpixel.x),mix(c01.gb,c11.gb,subpixel.x),subpixel.y)*out_moco_pos.z;\n"
\r
327 " c00=texture2D(backward_pic,moco_temp.zw*pict_size);\n"
\r
328 " c01=texture2D(backward_pic,(moco_temp.zw+vec2(czero,ctwo*out_misc_info.y))*pict_size);\n"
\r
329 " c10=texture2D(backward_pic,(moco_temp.zw+vec2(ctwo,czero))*pict_size);\n"
\r
330 " c11=texture2D(backward_pic,(moco_temp.zw+vec2(ctwo,ctwo*out_misc_info.y))*pict_size);\n"
\r
331 " our_fragcol.gb+=mix(mix(c00.gb,c10.gb,subpixel.z),mix(c01.gb,c11.gb,subpixel.z),subpixel.w)*out_moco_pos.w;\n"
\r
333 " gl_FragColor.rgb=vec3(our_fragcol.r,halfst,halfst);\n"
\r
334 " if (out_unsupported==1.) {\n"
\r
335 " gl_FragColor.gb=vec2(cone,0.0);\n"
\r
336 "}else if (out_unsupported==2.) {\n"
\r
337 " gl_FragColor.gb=vec2(0.0,cone);\n"
\r
341 //" ypos_temp2=mix(ypos_temp1.rg,ypos_temp1.ba,step(c1over2047,mod(ypos_temp2.x,c1over1023)));\n" //activate this
\r
344 //" gl_FragColor.r=subsample/acht;\n" //signed later TODO
\r
345 //" gl_FragColor.g=0.5;\n"
\r
346 //" gl_FragColor.b=0.5;\n"
\r
347 " gl_FragColor.a=1.0;\n"
\r
348 //" vec4 blocks=texture2D(blocks,gl_FragCoord.xy/600.);\n"
\r
349 // "help.x=texture2D(textureY,out_texCoord).r;\n"
\r
350 // "help.y=texture2D(textureU,out_texCoord).r;\n"
\r
351 // "help.z=texture2D(textureV,out_texCoord).r;\n" //-uv_corr;\n"
\r
352 // " gl_FragColor.rgba=blocks;\n"
\r
353 // " gl_FragColor.rgba=vec4(0.7,0.5,0.5,1.0);\n"
\r
354 //" gl_FragColor.a=1.;\n"
\r
357 GLMocoShader::GLMocoShader(): GLShader("GLMocoShader")
\r
364 GLMocoShader::~GLMocoShader()
\r
366 //parent does everything
\r
369 int GLMocoShader::init() {
\r
371 if (!initShaders(moco_vertex_shader, moco_frag_shader)) {
\r
372 Log::getInstance()->log("GLMocoShader", Log::ERR, "init Shaders failed for GLMocoShader");
\r
375 loc_pict_scale = glGetUniformLocation(shad_program, "pict_scale");
\r
376 blocks_loc = glGetUniformLocation(shad_program, "blocks");
\r
377 forward_pic_loc = glGetUniformLocation(shad_program, "forward_pic");
\r
378 backward_pic_loc = glGetUniformLocation(shad_program, "backward_pic");
\r
379 pict_size_loc = glGetUniformLocation(shad_program, "pict_size");
\r
381 // frame_sampler_locY = glGetUniformLocation(shad_program, "textureY");
\r
382 // Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locY,glGetError());
\r
383 // frame_sampler_locU = glGetUniformLocation(shad_program, "textureU");
\r
384 //Log::getInstance()->log("OSD", Log::WARN, "uniform location %x %x",frame_sampler_locU,glGetError());
\r
385 // frame_sampler_locV = glGetUniformLocation(shad_program, "textureV");
\r
386 glGenFramebuffers(1, &frame_buf);
\r
387 //Log::getInstance()->log("GLMocoShader", Log::WARN, "genframe bufmark1 glerror %x",glGetError());
\r
388 glGenTextures(1, &data_blocks);
\r
389 glBindTexture(GL_TEXTURE_2D, data_blocks);
\r
390 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, BLOCK_TEXTURE_WIDTH >>1, BLOCK_TEXTURE_HEIGHT, 0, GL_RGBA,
\r
391 GL_UNSIGNED_BYTE, NULL);
\r
392 char buffer[BLOCK_TEXTURE_WIDTH*2];
\r
393 memset(buffer,0,BLOCK_TEXTURE_WIDTH*2); // the last line is black, simplifies the shader algorithms
\r
395 glTexSubImage2D(GL_TEXTURE_2D,0,0,BLOCK_TEXTURE_HEIGHT-1,
\r
396 BLOCK_TEXTURE_WIDTH>>1,1,
\r
397 GL_RGBA,GL_UNSIGNED_BYTE,
\r
400 glGenBuffers(1,¯o_block);
\r
401 glBindBuffer(GL_ARRAY_BUFFER,macro_block);
\r
402 glBufferData(GL_ARRAY_BUFFER,4096*4*sizeof(XvMCMacroBlock),NULL,GL_DYNAMIC_DRAW);
\r
403 valid_macro_blocks=0;
\r
406 glGenBuffers(1,&triangles);
\r
407 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);
\r
408 GLushort *tri_indices=(GLushort *)malloc(sizeof(GLushort)*4096*6);
\r
409 if (!tri_indices) {
\r
410 Log::getInstance()->log("GLMocoShader", Log::WARN, "allocating triindices failed");
\r
413 GLushort *tri_indices_run=tri_indices;
\r
414 for (int i=0;i<4096;i++) {
\r
415 *tri_indices_run=i+0*4096; //strip
\r
417 *tri_indices_run=i+2*4096; //strip
\r
419 *tri_indices_run=i+1*4096; //strip
\r
421 *tri_indices_run=i+3*4096; //strip
\r
423 *tri_indices_run=i+3*4096; //strip
\r
425 *tri_indices_run=i+1+0*4096; //strip
\r
433 glBufferData(GL_ELEMENT_ARRAY_BUFFER,4096*6*sizeof(GLushort),tri_indices,GL_STREAM_DRAW);
\r
436 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
\r
437 glBindBuffer(GL_ARRAY_BUFFER,0);
\r
445 int GLMocoShader::deinit()
\r
447 glDeleteFramebuffers(1, &frame_buf);
\r
448 glDeleteTextures(1, &data_blocks);
\r
449 return deinitShaders();
\r
454 int GLMocoShader::uploadDataBlocks(short* blocks,unsigned int num_blocks, XvMCMacroBlock *m_blocks,unsigned int num_m_blocks)
\r
456 unsigned int height=(num_blocks)/(BLOCK_PER_ROW);
\r
458 glBindTexture(GL_TEXTURE_2D, data_blocks);
\r
459 glPixelStorei(GL_UNPACK_ALIGNMENT,1);
\r
464 // Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark1 glerror %x %d",glGetError(),height);
\r
465 glTexSubImage2D(GL_TEXTURE_2D,0,0,0,
\r
466 BLOCK_TEXTURE_WIDTH>>1,height,
\r
467 GL_RGBA,GL_UNSIGNED_BYTE,
\r
469 // Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());
\r
470 glTexSubImage2D(GL_TEXTURE_2D,0,0,height,
\r
471 ((num_blocks%BLOCK_PER_ROW)>>1)*BLOCK_SIZE,1,
\r
472 GL_RGBA,GL_UNSIGNED_BYTE,
\r
473 blocks+height*BLOCK_PER_ROW*BLOCK_SIZE);
\r
475 //Log::getInstance()->log("GLMocoShader", Log::WARN, "uploadDataBlocks mark2 glerror %x",glGetError());
\r
479 glBindTexture(GL_TEXTURE_2D, 0);
\r
481 valid_macro_blocks=num_m_blocks;
\r
482 glBindBuffer(GL_ARRAY_BUFFER,macro_block);
\r
483 XvMCMacroBlock *m_blocks_run=m_blocks;
\r
484 XvMCMacroBlock *m_blocks_end=m_blocks+num_m_blocks;
\r
485 while (m_blocks_run!=m_blocks_end) {
\r
486 m_blocks_run->pad0=0xFF00;
\r
490 /* m_blocks[0].x=0;
\r
492 m_blocks[3]=m_blocks[2]=m_blocks[1]=m_blocks[0];
\r
493 m_blocks[0].pad0=0xFF00;
\r
494 m_blocks[1].pad0=0xFFFF;
\r
495 m_blocks[2].pad0=0x0000;
\r
496 m_blocks[3].pad0=0x00FF;
\r
504 glBufferSubData(GL_ARRAY_BUFFER, 0* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),
\r
508 m_blocks_run = m_blocks;
\r
509 m_blocks_end = m_blocks + num_m_blocks;
\r
510 while (m_blocks_run != m_blocks_end) {
\r
511 m_blocks_run->pad0 = 0xFFFF;
\r
514 glBufferSubData(GL_ARRAY_BUFFER, 4096* sizeof(XvMCMacroBlock), num_m_blocks * sizeof(XvMCMacroBlock),
\r
518 m_blocks_run = m_blocks;
\r
519 m_blocks_end = m_blocks + num_m_blocks;
\r
520 while (m_blocks_run != m_blocks_end) {
\r
521 m_blocks_run->pad0 = 0x0000;
\r
524 glBufferSubData(GL_ARRAY_BUFFER, 2 * 4096* sizeof(XvMCMacroBlock),
\r
525 num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);
\r
528 m_blocks_run = m_blocks;
\r
529 m_blocks_end = m_blocks + num_m_blocks;
\r
530 while (m_blocks_run != m_blocks_end) {
\r
531 m_blocks_run->pad0 = 0x00FF;
\r
534 glBufferSubData(GL_ARRAY_BUFFER, 3 * 4096* sizeof(XvMCMacroBlock),
\r
535 num_m_blocks * sizeof(XvMCMacroBlock), m_blocks);
\r
538 glBindBuffer(GL_ARRAY_BUFFER,0);
\r
546 int GLMocoShader::doMoCo(VPEOGLFrame *target,VPEOGLFrame *forward,VPEOGLFrame *backward)
\r
549 // Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-2 glerror %x %x",glGetError(),frame_buf);
\r
551 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark-1 glerror %x %x",glGetError(),frame_buf);
\r
552 glBindFramebuffer(GL_FRAMEBUFFER, frame_buf);
\r
553 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1 glerror %x %x %x",glGetError(),target->textures[0],target->textures[1]);
\r
556 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
\r
557 GL_TEXTURE_2D, target->textures[0], 0);
\r
558 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark1apres glerror %x",glGetError());
\r
564 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2 glerror %x",glGetError());
\r
566 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2a glerror %x",glGetError());
\r
568 int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
\r
569 if (status == GL_FRAMEBUFFER_COMPLETE) {
\r
570 glViewport(0, 0, target->width,target->height);
\r
571 // Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2b glerror %x",glGetError());
\r
573 XvMCMacroBlock * helperp=NULL;
\r
575 glClearColor(0.0f,0.5f,0.5f,1.f); //this black
\r
576 glClear(GL_COLOR_BUFFER_BIT);
\r
577 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark2c glerror %x",glGetError());
\r
579 glUseProgram(shad_program);
\r
580 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());
\r
583 const GLfloat pict_scale[]={ 32./((float)target->width),32./((float)target->height)};
\r
585 glUniform2fv(loc_pict_scale,1,(const GLfloat*)&pict_scale);
\r
588 const GLfloat pict_size[]={ 1./((float)target->width),1./((float)target->height)};
\r
589 glUniform2fv(pict_size_loc,1,(const GLfloat*)&pict_size);
\r
591 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,triangles);
\r
592 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());
\r
593 glBindBuffer(GL_ARRAY_BUFFER,macro_block);
\r
597 glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,
\r
598 sizeof(XvMCMacroBlock), NULL);
\r
600 glEnableVertexAttribArray(0);
\r
602 glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));
\r
603 glEnableVertexAttribArray(1);
\r
605 glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->macroblock_type));
\r
606 glEnableVertexAttribArray(2);
\r
608 glVertexAttribPointer(3, 1, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->coded_block_pattern));
\r
609 glEnableVertexAttribArray(3);
\r
610 glVertexAttribPointer(4, 2, GL_UNSIGNED_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->index));
\r
611 glEnableVertexAttribArray(4);
\r
613 glVertexAttribPointer(5, 4, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->PMV[0][0][0]));
\r
614 glEnableVertexAttribArray(5);
\r
616 glVertexAttribPointer(6, 4, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), (const void *) &(helperp->PMV[1][0][0]));
\r
617 glEnableVertexAttribArray(6);
\r
622 glActiveTexture(GL_TEXTURE0);
\r
623 glBindTexture(GL_TEXTURE_2D,data_blocks);
\r
624 glUniform1i(blocks_loc,0);
\r
625 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
\r
626 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
\r
627 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
\r
628 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
\r
633 Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo forward %x",forward->textures[0]);
\r
634 glActiveTexture(GL_TEXTURE1);
\r
635 glBindTexture(GL_TEXTURE_2D,forward->textures[0]);
\r
636 glUniform1i(forward_pic_loc,1);
\r
637 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
\r
638 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
\r
639 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
\r
640 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
\r
645 glActiveTexture(GL_TEXTURE2);
\r
646 Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo backward %x",backward->textures[0]);
\r
647 glBindTexture(GL_TEXTURE_2D,backward->textures[0]);
\r
648 glUniform1i(backward_pic_loc,2);
\r
649 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
\r
650 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
\r
651 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
\r
652 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
\r
658 glDrawElements(GL_TRIANGLE_STRIP, valid_macro_blocks*6,
\r
659 GL_UNSIGNED_SHORT, NULL);
\r
663 glVertexAttribPointer(0, 2, GL_SHORT, GL_FALSE,sizeof(XvMCMacroBlock), 0);
\r
664 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());
\r
665 glEnableVertexAttribArray(0);
\r
667 glVertexAttribPointer(1, 2, GL_UNSIGNED_BYTE, GL_TRUE,sizeof(XvMCMacroBlock), (const void *) &(helperp->pad0));
\r
668 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark3 glerror %x",glGetError());
\r
669 glEnableVertexAttribArray(1);*/
\r
671 // Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark4 glerror %x",glGetError());
\r
674 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark6 glerror %x",glGetError());
\r
676 // glDrawElements(GL_TRIANGLE_STRIP,/*valid_macro_blocks*/4,GL_UNSIGNED_SHORT,0);
\r
677 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark7 glerror %x %x",glGetError(),valid_macro_blocks);
\r
680 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
\r
681 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark5 glerror %x",glGetError());
\r
682 glBindBuffer(GL_ARRAY_BUFFER,0);
\r
684 glBindFramebuffer(GL_FRAMEBUFFER, 0);
\r
685 glActiveTexture(GL_TEXTURE0);
\r
686 glBindTexture(GL_TEXTURE_2D, 0);
\r
687 glActiveTexture(GL_TEXTURE1);
\r
688 glBindTexture(GL_TEXTURE_2D, 0);
\r
689 glActiveTexture(GL_TEXTURE2);
\r
690 glBindTexture(GL_TEXTURE_2D, 0);
\r
691 //Log::getInstance()->log("GLMocoShader", Log::WARN, "doMoCo mark8 glerror %x",glGetError());
\r
693 glBindFramebuffer(GL_FRAMEBUFFER, 0);
\r
694 Log::getInstance()->log("GLMocoShader", Log::WARN, "framebuffer not complete %x",status);
\r
698 glFinish(); // since the main rendering is done in a different thread we have to make sure rendering is finished before passing the texture
\r
699 // call this only in the last stage of rendering the moco frame
\r
708 int GLMocoShader::PrepareRendering(GLuint y_tex, GLuint u_tex, GLuint v_tex) { // This Function setups the rendering pipeline according to the shaders standards
\r
710 //Log::getInstance()->log("OSD", Log::WARN, "mark1 glerror %x",glGetError());
\r
713 //Log::getInstance()->log("OSD", Log::WARN, "mark2 glerror %x",glGetError());
\r
716 glActiveTexture( GL_TEXTURE2);
\r
717 glBindTexture(GL_TEXTURE_2D, v_tex);
\r
718 glUniform1i(frame_sampler_locV, 2);
\r
719 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
720 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
722 glActiveTexture( GL_TEXTURE1);
\r
723 glBindTexture(GL_TEXTURE_2D, u_tex);
\r
724 glUniform1i(frame_sampler_locU, 1);
\r
725 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
726 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
728 glActiveTexture( GL_TEXTURE0);
\r
729 glBindTexture(GL_TEXTURE_2D, y_tex);
\r
730 glUniform1i(frame_sampler_locY, 0);
\r
731 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
\r
732 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
\r
737 int GLMocoShader::BindAttributes()
\r
739 glBindAttribLocation(shad_program,0,"block_pos");
\r
740 glBindAttribLocation(shad_program,1,"block_edge");
\r
741 glBindAttribLocation(shad_program,2,"block_types");
\r
742 glBindAttribLocation(shad_program,3,"cbp");
\r
743 glBindAttribLocation(shad_program,4,"index");
\r
744 glBindAttribLocation(shad_program,5,"PMV1");
\r
745 glBindAttribLocation(shad_program,6,"PMV2");
\r
747 //glBindAttribLocation(shad_program,1,"tex_coord");
\r