fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-22 06:38:09 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

g3dvl: Use ureg to build shaders.

Browse source
This commit is contained in:
Younes Manton 2009-11-07 19:46:33 -05:00
parent 09878fb91a
commit e57f7b7b10
6 changed files with 247 additions and 936 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/gallium/auxiliary/vl/Makefile
View file

@ -7,7 +7,6 @@ C_SOURCES = \
vl_bitstream_parser.c \
vl_mpeg12_mc_renderer.c \
vl_compositor.c \
vl_csc.c \
vl_shader_build.c
vl_csc.c
include ../../Makefile.template

1
src/gallium/auxiliary/vl/SConscript
View file

@ -7,7 +7,6 @@ vl = env.ConvenienceLibrary(
'vl_mpeg12_mc_renderer.c',
'vl_compositor.c',
'vl_csc.c',
'vl_shader_build.c',
])
auxiliaries.insert(0, vl)

187
src/gallium/auxiliary/vl/vl_compositor.c
View file

@ -29,11 +29,9 @@
#include <assert.h>
#include <pipe/p_context.h>
#include <pipe/p_inlines.h>
#include <tgsi/tgsi_parse.h>
#include <tgsi/tgsi_build.h>
#include <tgsi/tgsi_ureg.h>
#include <util/u_memory.h>
#include "vl_csc.h"
#include "vl_shader_build.h"
struct vertex2f
{
@ -76,156 +74,81 @@ static const struct vertex2f surface_verts[4] =
*/
static const struct vertex2f *surface_texcoords = surface_verts;
static void
static bool
create_vert_shader(struct vl_compositor *c)
{
const unsigned max_tokens = 50;
struct ureg_program *shader;
struct ureg_src vpos, vtex;
struct ureg_src vpos_scale, vpos_trans, vtex_scale, vtex_trans;
struct ureg_dst o_vpos, o_vtex;
shader = ureg_create(TGSI_PROCESSOR_VERTEX);
if (!shader)
return false;
struct pipe_shader_state vs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
unsigned i;
assert(c);
tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version*)&tokens[0] = tgsi_build_version();
header = (struct tgsi_header*)&tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
ti = 3;
vpos = ureg_DECL_vs_input(shader, 0);
vtex = ureg_DECL_vs_input(shader, 1);
vpos_scale = ureg_DECL_constant(shader, 0);
vpos_trans = ureg_DECL_constant(shader, 1);
vtex_scale = ureg_DECL_constant(shader, 2);
vtex_trans = ureg_DECL_constant(shader, 3);
o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, 0);
o_vtex = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, 1);
/*
* decl i0 ; Vertex pos
* decl i1 ; Vertex texcoords
* o_vpos = vpos * vpos_scale + vpos_trans
* o_vtex = vtex * vtex_scale + vtex_trans
*/
for (i = 0; i < 2; i++) {
decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_MAD(shader, o_vpos, vpos, vpos_scale, vpos_trans);
ureg_MAD(shader, o_vtex, vtex, vtex_scale, vtex_trans);
/*
* decl c0 ; Scaling vector to scale vertex pos rect to destination size
* decl c1 ; Translation vector to move vertex pos rect into position
* decl c2 ; Scaling vector to scale texcoord rect to source size
* decl c3 ; Translation vector to move texcoord rect into position
*/
decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
ureg_END(shader);
/*
* decl o0 ; Vertex pos
* decl o1 ; Vertex texcoords
*/
for (i = 0; i < 2; i++) {
decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
c->vertex_shader = ureg_create_shader_and_destroy(shader, c->pipe);
if (!c->vertex_shader)
return false;
/* decl t0, t1 */
decl = vl_decl_temps(0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* mad o0, i0, c0, c1 ; Scale and translate unit output rect to destination size and pos
* mad o1, i1, c2, c3 ; Scale and translate unit texcoord rect to source size and pos
*/
for (i = 0; i < 2; ++i) {
inst = vl_inst4(TGSI_OPCODE_MAD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
vs.tokens = tokens;
c->vertex_shader = c->pipe->create_vs_state(c->pipe, &vs);
FREE(tokens);
return true;
}
static void
static bool
create_frag_shader(struct vl_compositor *c)
{
const unsigned max_tokens = 50;
struct pipe_shader_state fs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src tc;
struct ureg_src csc[4];
struct ureg_src sampler;
struct ureg_dst texel;
struct ureg_dst fragment;
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
if (!shader)
return false;
assert(c);
tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version*)&tokens[0] = tgsi_build_version();
header = (struct tgsi_header*)&tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
ti = 3;
/* decl i0 ; Texcoords for s0 */
decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, 1, 0, 0, TGSI_INTERPOLATE_LINEAR);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
tc = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, 1, TGSI_INTERPOLATE_LINEAR);
for (i = 0; i < 4; ++i)
csc[i] = ureg_DECL_constant(shader, i);
sampler = ureg_DECL_sampler(shader, 0);
texel = ureg_DECL_temporary(shader);
fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
/*
* decl c0-c3 ; CSC matrix c0-c3
* texel = tex(tc, sampler)
* fragment = csc * texel
*/
decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
ureg_TEX(shader, texel, TGSI_TEXTURE_2D, tc, sampler);
for (i = 0; i < 4; ++i)
ureg_DP4(shader, ureg_writemask(fragment, TGSI_WRITEMASK_X << i), csc[i], ureg_src(texel));
/* decl o0 ; Fragment color */
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
ureg_release_temporary(shader, texel);
ureg_END(shader);
/* decl t0 */
decl = vl_decl_temps(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
c->fragment_shader = ureg_create_shader_and_destroy(shader, c->pipe);
if (!c->fragment_shader)
return false;
/* decl s0 ; Sampler for tex containing picture to display */
decl = vl_decl_samplers(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* tex2d t0, i0, s0 ; Read src pixel */
inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_SAMPLER, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/*
* dp4 o0.x, t0, c0 ; Multiply pixel by the color conversion matrix
* dp4 o0.y, t0, c1
* dp4 o0.z, t0, c2
* dp4 o0.w, t0, c3
*/
for (i = 0; i < 4; ++i) {
inst = vl_inst3(TGSI_OPCODE_DP4, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, i);
inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
fs.tokens = tokens;
c->fragment_shader = c->pipe->create_fs_state(c->pipe, &fs);
FREE(tokens);
return true;
}
static bool

662
src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.c
View file

@ -31,9 +31,7 @@
#include <pipe/p_inlines.h>
#include <util/u_math.h>
#include <util/u_memory.h>
#include <tgsi/tgsi_parse.h>
#include <tgsi/tgsi_build.h>
#include "vl_shader_build.h"
#include <tgsi/tgsi_ureg.h>
#define DEFAULT_BUF_ALIGNMENT 1
#define MACROBLOCK_WIDTH 16
@ -96,244 +94,126 @@ enum MACROBLOCK_TYPE
NUM_MACROBLOCK_TYPES
};
static void
static bool
create_intra_vert_shader(struct vl_mpeg12_mc_renderer *r)
{
const unsigned max_tokens = 50;
struct pipe_shader_state vs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src vpos, vtex[3];
struct ureg_dst o_vpos, o_vtex[3];
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_VERTEX);
if (!shader)
return false;
assert(r);
tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
header = (struct tgsi_header *) &tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor *) &tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
ti = 3;
vpos = ureg_DECL_vs_input(shader, 0);
for (i = 0; i < 3; ++i)
vtex[i] = ureg_DECL_vs_input(shader, i + 1);
o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, 0);
for (i = 0; i < 3; ++i)
o_vtex[i] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, i + 1);
/*
* decl i0 ; Vertex pos
* decl i1 ; Luma texcoords
* decl i2 ; Chroma Cb texcoords
* decl i3 ; Chroma Cr texcoords
* o_vpos = vpos
* o_vtex[0..2] = vtex[0..2]
*/
for (i = 0; i < 4; i++) {
decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_MOV(shader, o_vpos, vpos);
for (i = 0; i < 3; ++i)
ureg_MOV(shader, o_vtex[i], vtex[i]);
/*
* decl o0 ; Vertex pos
* decl o1 ; Luma texcoords
* decl o2 ; Chroma Cb texcoords
* decl o3 ; Chroma Cr texcoords
*/
for (i = 0; i < 4; i++) {
decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_END(shader);
/*
* mov o0, i0 ; Move input vertex pos to output
* mov o1, i1 ; Move input luma texcoords to output
* mov o2, i2 ; Move input chroma Cb texcoords to output
* mov o3, i3 ; Move input chroma Cr texcoords to output
*/
for (i = 0; i < 4; ++i) {
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
r->i_vs = ureg_create_shader_and_destroy(shader, r->pipe);
if (!r->i_vs)
return false;
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
vs.tokens = tokens;
r->i_vs = r->pipe->create_vs_state(r->pipe, &vs);
free(tokens);
return true;
}
static void
static bool
create_intra_frag_shader(struct vl_mpeg12_mc_renderer *r)
{
const unsigned max_tokens = 100;
struct pipe_shader_state fs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src scale;
struct ureg_src tc[3];
struct ureg_src sampler[3];
struct ureg_dst texel, temp;
struct ureg_dst fragment;
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
if (!shader)
return false;
assert(r);
tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
header = (struct tgsi_header *) &tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor *) &tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
ti = 3;
scale = ureg_DECL_constant(shader, 0);
for (i = 0; i < 3; ++i) {
tc[i] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, i + 1, TGSI_INTERPOLATE_LINEAR);
sampler[i] = ureg_DECL_sampler(shader, i);
}
texel = ureg_DECL_temporary(shader);
temp = ureg_DECL_temporary(shader);
fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
/*
* decl i0 ; Luma texcoords
* decl i1 ; Chroma Cb texcoords
* decl i2 ; Chroma Cr texcoords
* texel.r = tex(tc[0], sampler[0])
* texel.g = tex(tc[1], sampler[1])
* texel.b = tex(tc[2], sampler[2])
* fragment = texel * scale
*/
for (i = 0; i < 3; ++i) {
decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* Nouveau can't writemask tex dst regs (yet?), do in two steps */
ureg_TEX(shader, temp, TGSI_TEXTURE_2D, tc[i], sampler[i]);
ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), ureg_scalar(ureg_src(temp), TGSI_SWIZZLE_X));
}
ureg_MUL(shader, fragment, ureg_src(texel), scale);
/* decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm */
decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
ureg_release_temporary(shader, texel);
ureg_release_temporary(shader, temp);
ureg_END(shader);
/* decl o0 ; Fragment color */
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
r->i_fs = ureg_create_shader_and_destroy(shader, r->pipe);
if (!r->i_fs)
return false;
/* decl t0, t1 */
decl = vl_decl_temps(0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
* decl s2 ; Sampler for chroma Cr texture
*/
for (i = 0; i < 3; ++i) {
decl = vl_decl_samplers(i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/*
* tex2d t1, i0, s0 ; Read texel from luma texture
* mov t0.x, t1.x ; Move luma sample into .x component
* tex2d t1, i1, s1 ; Read texel from chroma Cb texture
* mov t0.y, t1.x ; Move Cb sample into .y component
* tex2d t1, i2, s2 ; Read texel from chroma Cr texture
* mov t0.z, t1.x ; Move Cr sample into .z component
*/
for (i = 0; i < 3; ++i) {
inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
/* mul o0, t0, c0 ; Rescale texel to correct range */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
fs.tokens = tokens;
r->i_fs = r->pipe->create_fs_state(r->pipe, &fs);
free(tokens);
return true;
}
static void
static bool
create_frame_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
{
const unsigned max_tokens = 100;
struct pipe_shader_state vs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src vpos, vtex[4];
struct ureg_dst o_vpos, o_vtex[4];
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_VERTEX);
if (!shader)
return false;
assert(r);
tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
header = (struct tgsi_header *) &tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor *) &tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
ti = 3;
vpos = ureg_DECL_vs_input(shader, 0);
for (i = 0; i < 4; ++i)
vtex[i] = ureg_DECL_vs_input(shader, i + 1);
o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, 0);
for (i = 0; i < 4; ++i)
o_vtex[i] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, i + 1);
/*
* decl i0 ; Vertex pos
* decl i1 ; Luma texcoords
* decl i2 ; Chroma Cb texcoords
* decl i3 ; Chroma Cr texcoords
* decl i4 ; Ref surface top field texcoords
* decl i5 ; Ref surface bottom field texcoords (unused, packed in the same stream)
* o_vpos = vpos
* o_vtex[0..2] = vtex[0..2]
* o_vtex[3] = vpos + vtex[3] // Apply motion vector
*/
for (i = 0; i < 6; i++) {
decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_MOV(shader, o_vpos, vpos);
for (i = 0; i < 3; ++i)
ureg_MOV(shader, o_vtex[i], vtex[i]);
ureg_ADD(shader, o_vtex[3], vpos, vtex[3]);
/*
* decl o0 ; Vertex pos
* decl o1 ; Luma texcoords
* decl o2 ; Chroma Cb texcoords
* decl o3 ; Chroma Cr texcoords
* decl o4 ; Ref macroblock texcoords
*/
for (i = 0; i < 5; i++) {
decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_END(shader);
/*
* mov o0, i0 ; Move input vertex pos to output
* mov o1, i1 ; Move input luma texcoords to output
* mov o2, i2 ; Move input chroma Cb texcoords to output
* mov o3, i3 ; Move input chroma Cr texcoords to output
*/
for (i = 0; i < 4; ++i) {
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
r->p_vs[0] = ureg_create_shader_and_destroy(shader, r->pipe);
if (!r->p_vs[0])
return false;
/* add o4, i0, i4 ; Translate vertex pos by motion vec to form ref macroblock texcoords */
inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, 4);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
vs.tokens = tokens;
r->p_vs[0] = r->pipe->create_vs_state(r->pipe, &vs);
free(tokens);
return true;
}
static void
@ -342,107 +222,54 @@ create_field_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
assert(false);
}
static void
static bool
create_frame_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
{
const unsigned max_tokens = 100;
struct pipe_shader_state fs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src scale;
struct ureg_src tc[4];
struct ureg_src sampler[4];
struct ureg_dst texel, ref;
struct ureg_dst fragment;
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
if (!shader)
return false;
assert(r);
tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
header = (struct tgsi_header *) &tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor *) &tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
ti = 3;
/*
* decl i0 ; Luma texcoords
* decl i1 ; Chroma Cb texcoords
* decl i2 ; Chroma Cr texcoords
* decl i3 ; Ref macroblock texcoords
*/
for (i = 0; i < 4; ++i) {
decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
scale = ureg_DECL_constant(shader, 0);
for (i = 0; i < 4; ++i) {
tc[i] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, i + 1, TGSI_INTERPOLATE_LINEAR);
sampler[i] = ureg_DECL_sampler(shader, i);
}
/* decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm */
decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl o0 ; Fragment color */
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0, t1 */
decl = vl_decl_temps(0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
texel = ureg_DECL_temporary(shader);
ref = ureg_DECL_temporary(shader);
fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
* decl s2 ; Sampler for chroma Cr texture
* decl s3 ; Sampler for ref surface texture
*/
for (i = 0; i < 4; ++i) {
decl = vl_decl_samplers(i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/*
* tex2d t1, i0, s0 ; Read texel from luma texture
* mov t0.x, t1.x ; Move luma sample into .x component
* tex2d t1, i1, s1 ; Read texel from chroma Cb texture
* mov t0.y, t1.x ; Move Cb sample into .y component
* tex2d t1, i2, s2 ; Read texel from chroma Cr texture
* mov t0.z, t1.x ; Move Cr sample into .z component
* texel.r = tex(tc[0], sampler[0])
* texel.g = tex(tc[1], sampler[1])
* texel.b = tex(tc[2], sampler[2])
* ref = tex(tc[3], sampler[3])
* fragment = texel * scale + ref
*/
for (i = 0; i < 3; ++i) {
inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* Nouveau can't writemask tex dst regs (yet?), do in two steps */
ureg_TEX(shader, ref, TGSI_TEXTURE_2D, tc[i], sampler[i]);
ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), ureg_scalar(ureg_src(ref), TGSI_SWIZZLE_X));
}
ureg_TEX(shader, ref, TGSI_TEXTURE_2D, tc[3], sampler[3]);
ureg_MAD(shader, fragment, ureg_src(texel), scale, ureg_src(ref));
/* mul t0, t0, c0 ; Rescale texel to correct range */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
ureg_release_temporary(shader, texel);
ureg_release_temporary(shader, ref);
ureg_END(shader);
/* tex2d t1, i3, s3 ; Read texel from ref macroblock */
inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, 3, TGSI_FILE_SAMPLER, 3);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
r->p_fs[0] = ureg_create_shader_and_destroy(shader, r->pipe);
if (!r->p_fs[0])
return false;
/* add o0, t0, t1 ; Add ref and differential to form final output */
inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
fs.tokens = tokens;
r->p_fs[0] = r->pipe->create_fs_state(r->pipe, &fs);
free(tokens);
return true;
}
static void
@ -451,89 +278,45 @@ create_field_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
assert(false);
}
static void
static bool
create_frame_bi_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
{
const unsigned max_tokens = 100;
struct pipe_shader_state vs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src vpos, vtex[5];
struct ureg_dst o_vpos, o_vtex[5];
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_VERTEX);
if (!shader)
return false;
assert(r);
tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
header = (struct tgsi_header *) &tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor *) &tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
ti = 3;
vpos = ureg_DECL_vs_input(shader, 0);
for (i = 0; i < 4; ++i)
vtex[i] = ureg_DECL_vs_input(shader, i + 1);
/* Skip input 5 */
vtex[4] = ureg_DECL_vs_input(shader, 6);
o_vpos = ureg_DECL_output(shader, TGSI_SEMANTIC_POSITION, 0);
for (i = 0; i < 5; ++i)
o_vtex[i] = ureg_DECL_output(shader, TGSI_SEMANTIC_GENERIC, i + 1);
/*
* decl i0 ; Vertex pos
* decl i1 ; Luma texcoords
* decl i2 ; Chroma Cb texcoords
* decl i3 ; Chroma Cr texcoords
* decl i4 ; First ref macroblock top field texcoords
* decl i5 ; First ref macroblock bottom field texcoords (unused, packed in the same stream)
* decl i6 ; Second ref macroblock top field texcoords
* decl i7 ; Second ref macroblock bottom field texcoords (unused, packed in the same stream)
* o_vpos = vpos
* o_vtex[0..2] = vtex[0..2]
* o_vtex[3..4] = vpos + vtex[3..4] // Apply motion vector
*/
for (i = 0; i < 8; i++) {
decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_MOV(shader, o_vpos, vpos);
for (i = 0; i < 3; ++i)
ureg_MOV(shader, o_vtex[i], vtex[i]);
for (i = 3; i < 5; ++i)
ureg_ADD(shader, o_vtex[i], vpos, vtex[i]);
/*
* decl o0 ; Vertex pos
* decl o1 ; Luma texcoords
* decl o2 ; Chroma Cb texcoords
* decl o3 ; Chroma Cr texcoords
* decl o4 ; First ref macroblock texcoords
* decl o5 ; Second ref macroblock texcoords
*/
for (i = 0; i < 6; i++) {
decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
ureg_END(shader);
/*
* mov o0, i0 ; Move input vertex pos to output
* mov o1, i1 ; Move input luma texcoords to output
* mov o2, i2 ; Move input chroma Cb texcoords to output
* mov o3, i3 ; Move input chroma Cr texcoords to output
*/
for (i = 0; i < 4; ++i) {
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
r->b_vs[0] = ureg_create_shader_and_destroy(shader, r->pipe);
if (!r->b_vs[0])
return false;
/*
* add o4, i0, i4 ; Translate vertex pos by motion vec to form first ref macroblock texcoords
* add o5, i0, i6 ; Translate vertex pos by motion vec to form second ref macroblock texcoords
*/
for (i = 0; i < 2; ++i) {
inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, i + 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, (i + 2) * 2);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
vs.tokens = tokens;
r->b_vs[0] = r->pipe->create_vs_state(r->pipe, &vs);
free(tokens);
return true;
}
static void
@ -542,125 +325,62 @@ create_field_bi_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
assert(false);
}
static void
static bool
create_frame_bi_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
{
const unsigned max_tokens = 100;
struct pipe_shader_state fs;
struct tgsi_token *tokens;
struct tgsi_header *header;
struct tgsi_full_declaration decl;
struct tgsi_full_instruction inst;
unsigned ti;
struct ureg_program *shader;
struct ureg_src scale, blend;
struct ureg_src tc[5];
struct ureg_src sampler[5];
struct ureg_dst texel, ref[2];
struct ureg_dst fragment;
unsigned i;
shader = ureg_create(TGSI_PROCESSOR_FRAGMENT);
if (!shader)
return false;
assert(r);
tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
*(struct tgsi_version *) &tokens[0] = tgsi_build_version();
header = (struct tgsi_header *) &tokens[1];
*header = tgsi_build_header();
*(struct tgsi_processor *) &tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
ti = 3;
/*
* decl i0 ; Luma texcoords
* decl i1 ; Chroma Cb texcoords
* decl i2 ; Chroma Cr texcoords
* decl i3 ; First ref macroblock texcoords
* decl i4 ; Second ref macroblock texcoords
*/
for (i = 0; i < 5; ++i) {
decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
scale = ureg_DECL_constant(shader, 0);
blend = ureg_DECL_constant(shader, 1);
for (i = 0; i < 5; ++i) {
tc[i] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, i + 1, TGSI_INTERPOLATE_LINEAR);
sampler[i] = ureg_DECL_sampler(shader, i);
}
texel = ureg_DECL_temporary(shader);
ref[0] = ureg_DECL_temporary(shader);
ref[1] = ureg_DECL_temporary(shader);
fragment = ureg_DECL_output(shader, TGSI_SEMANTIC_COLOR, 0);
/*
* decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm
* decl c1 ; Constant 1/2 in .x channel to use as weight to blend past and future texels
*/
decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl o0 ; Fragment color */
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0-t2 */
decl = vl_decl_temps(0, 2);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
* decl s2 ; Sampler for chroma Cr texture
* decl s3 ; Sampler for first ref surface texture
* decl s4 ; Sampler for second ref surface texture
*/
for (i = 0; i < 5; ++i) {
decl = vl_decl_samplers(i, i);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/*
* tex2d t1, i0, s0 ; Read texel from luma texture
* mov t0.x, t1.x ; Move luma sample into .x component
* tex2d t1, i1, s1 ; Read texel from chroma Cb texture
* mov t0.y, t1.x ; Move Cb sample into .y component
* tex2d t1, i2, s2 ; Read texel from chroma Cr texture
* mov t0.z, t1.x ; Move Cr sample into .z component
* texel.r = tex(tc[0], sampler[0])
* texel.g = tex(tc[1], sampler[1])
* texel.b = tex(tc[2], sampler[2])
* ref[0..1 = tex(tc[3..4], sampler[3..4])
* ref[0] = lerp(ref[0], ref[1], 0.5)
* fragment = texel * scale + ref[0]
*/
for (i = 0; i < 3; ++i) {
inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* Nouveau can't writemask tex dst regs (yet?), do in two steps */
ureg_TEX(shader, ref[0], TGSI_TEXTURE_2D, tc[i], sampler[i]);
ureg_MOV(shader, ureg_writemask(texel, TGSI_WRITEMASK_X << i), ureg_scalar(ureg_src(ref[0]), TGSI_SWIZZLE_X));
}
ureg_TEX(shader, ref[0], TGSI_TEXTURE_2D, tc[3], sampler[3]);
ureg_TEX(shader, ref[1], TGSI_TEXTURE_2D, tc[4], sampler[4]);
ureg_LRP(shader, ref[0], ureg_swizzle(blend, TGSI_SWIZZLE_X, TGSI_SWIZZLE_X, TGSI_SWIZZLE_X, TGSI_SWIZZLE_X),
ureg_src(ref[0]), ureg_src(ref[1]));
/* mul t0, t0, c0 ; Rescale texel to correct range */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
ureg_MAD(shader, fragment, ureg_src(texel), scale, ureg_src(ref[0]));
/*
* tex2d t1, i3, s3 ; Read texel from first ref macroblock
* tex2d t2, i4, s4 ; Read texel from second ref macroblock
*/
for (i = 0; i < 2; ++i) {
inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, i + 1, TGSI_FILE_INPUT, i + 3, TGSI_FILE_SAMPLER, i + 3);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
}
ureg_release_temporary(shader, texel);
ureg_release_temporary(shader, ref[0]);
ureg_release_temporary(shader, ref[1]);
ureg_END(shader);
/* lerp t1, c1.x, t1, t2 ; Blend past and future texels */
inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
inst.FullSrcRegisters[0].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
r->b_fs[0] = ureg_create_shader_and_destroy(shader, r->pipe);
if (!r->b_fs[0])
return false;
/* add o0, t0, t1 ; Add past/future ref and differential to form final output */
inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
/* end */
inst = vl_end();
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
assert(ti <= max_tokens);
fs.tokens = tokens;
r->b_fs[0] = r->pipe->create_fs_state(r->pipe, &fs);
free(tokens);
return true;
}
static void

242
src/gallium/auxiliary/vl/vl_shader_build.c
View file

@ -1,242 +0,0 @@
/**************************************************************************
*
* Copyright 2009 Younes Manton.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "vl_shader_build.h"
#include <assert.h>
#include <tgsi/tgsi_parse.h>
#include <tgsi/tgsi_build.h>
struct tgsi_full_declaration vl_decl_input(unsigned int name, unsigned int index, unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
decl.Declaration.File = TGSI_FILE_INPUT;
decl.Declaration.Semantic = 1;
decl.Semantic.SemanticName = name;
decl.Semantic.SemanticIndex = index;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_declaration vl_decl_interpolated_input
(
unsigned int name,
unsigned int index,
unsigned int first,
unsigned int last,
int interpolation
)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
assert
(
interpolation == TGSI_INTERPOLATE_CONSTANT ||
interpolation == TGSI_INTERPOLATE_LINEAR ||
interpolation == TGSI_INTERPOLATE_PERSPECTIVE
);
decl.Declaration.File = TGSI_FILE_INPUT;
decl.Declaration.Semantic = 1;
decl.Semantic.SemanticName = name;
decl.Semantic.SemanticIndex = index;
decl.Declaration.Interpolate = interpolation;;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_declaration vl_decl_constants(unsigned int name, unsigned int index, unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
decl.Declaration.File = TGSI_FILE_CONSTANT;
decl.Declaration.Semantic = 1;
decl.Semantic.SemanticName = name;
decl.Semantic.SemanticIndex = index;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_declaration vl_decl_output(unsigned int name, unsigned int index, unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
decl.Declaration.File = TGSI_FILE_OUTPUT;
decl.Declaration.Semantic = 1;
decl.Semantic.SemanticName = name;
decl.Semantic.SemanticIndex = index;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_declaration vl_decl_temps(unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
decl = tgsi_default_full_declaration();
decl.Declaration.File = TGSI_FILE_TEMPORARY;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_declaration vl_decl_samplers(unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
decl = tgsi_default_full_declaration();
decl.Declaration.File = TGSI_FILE_SAMPLER;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_instruction vl_inst2
(
int opcode,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src_file,
unsigned int src_index
)
{
struct tgsi_full_instruction inst = tgsi_default_full_instruction();
inst.Instruction.Opcode = opcode;
inst.Instruction.NumDstRegs = 1;
inst.FullDstRegisters[0].DstRegister.File = dst_file;
inst.FullDstRegisters[0].DstRegister.Index = dst_index;
inst.Instruction.NumSrcRegs = 1;
inst.FullSrcRegisters[0].SrcRegister.File = src_file;
inst.FullSrcRegisters[0].SrcRegister.Index = src_index;
return inst;
}
struct tgsi_full_instruction vl_inst3
(
int opcode,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src1_file,
unsigned int src1_index,
enum tgsi_file_type src2_file,
unsigned int src2_index
)
{
struct tgsi_full_instruction inst = tgsi_default_full_instruction();
inst.Instruction.Opcode = opcode;
inst.Instruction.NumDstRegs = 1;
inst.FullDstRegisters[0].DstRegister.File = dst_file;
inst.FullDstRegisters[0].DstRegister.Index = dst_index;
inst.Instruction.NumSrcRegs = 2;
inst.FullSrcRegisters[0].SrcRegister.File = src1_file;
inst.FullSrcRegisters[0].SrcRegister.Index = src1_index;
inst.FullSrcRegisters[1].SrcRegister.File = src2_file;
inst.FullSrcRegisters[1].SrcRegister.Index = src2_index;
return inst;
}
struct tgsi_full_instruction vl_tex
(
int tex,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src1_file,
unsigned int src1_index,
enum tgsi_file_type src2_file,
unsigned int src2_index
)
{
struct tgsi_full_instruction inst = tgsi_default_full_instruction();
inst.Instruction.Opcode = TGSI_OPCODE_TEX;
inst.Instruction.NumDstRegs = 1;
inst.FullDstRegisters[0].DstRegister.File = dst_file;
inst.FullDstRegisters[0].DstRegister.Index = dst_index;
inst.Instruction.NumSrcRegs = 2;
inst.InstructionExtTexture.Texture = tex;
inst.FullSrcRegisters[0].SrcRegister.File = src1_file;
inst.FullSrcRegisters[0].SrcRegister.Index = src1_index;
inst.FullSrcRegisters[1].SrcRegister.File = src2_file;
inst.FullSrcRegisters[1].SrcRegister.Index = src2_index;
return inst;
}
struct tgsi_full_instruction vl_inst4
(
int opcode,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src1_file,
unsigned int src1_index,
enum tgsi_file_type src2_file,
unsigned int src2_index,
enum tgsi_file_type src3_file,
unsigned int src3_index
)
{
struct tgsi_full_instruction inst = tgsi_default_full_instruction();
inst.Instruction.Opcode = opcode;
inst.Instruction.NumDstRegs = 1;
inst.FullDstRegisters[0].DstRegister.File = dst_file;
inst.FullDstRegisters[0].DstRegister.Index = dst_index;
inst.Instruction.NumSrcRegs = 3;
inst.FullSrcRegisters[0].SrcRegister.File = src1_file;
inst.FullSrcRegisters[0].SrcRegister.Index = src1_index;
inst.FullSrcRegisters[1].SrcRegister.File = src2_file;
inst.FullSrcRegisters[1].SrcRegister.Index = src2_index;
inst.FullSrcRegisters[2].SrcRegister.File = src3_file;
inst.FullSrcRegisters[2].SrcRegister.Index = src3_index;
return inst;
}
struct tgsi_full_instruction vl_end(void)
{
struct tgsi_full_instruction inst = tgsi_default_full_instruction();
inst.Instruction.Opcode = TGSI_OPCODE_END;
inst.Instruction.NumDstRegs = 0;
inst.Instruction.NumSrcRegs = 0;
return inst;
}

88
src/gallium/auxiliary/vl/vl_shader_build.h
View file

@ -1,88 +0,0 @@
/**************************************************************************
*
* Copyright 2009 Younes Manton.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#ifndef vl_shader_build_h
#define vl_shader_build_h
#include <pipe/p_shader_tokens.h>
struct tgsi_full_declaration vl_decl_input(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_interpolated_input
(
unsigned int name,
unsigned int index,
unsigned int first,
unsigned int last,
int interpolation
);
struct tgsi_full_declaration vl_decl_constants(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_output(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_temps(unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_samplers(unsigned int first, unsigned int last);
struct tgsi_full_instruction vl_inst2
(
int opcode,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src_file,
unsigned int src_index
);
struct tgsi_full_instruction vl_inst3
(
int opcode,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src1_file,
unsigned int src1_index,
enum tgsi_file_type src2_file,
unsigned int src2_index
);
struct tgsi_full_instruction vl_tex
(
int tex,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src1_file,
unsigned int src1_index,
enum tgsi_file_type src2_file,
unsigned int src2_index
);
struct tgsi_full_instruction vl_inst4
(
int opcode,
enum tgsi_file_type dst_file,
unsigned int dst_index,
enum tgsi_file_type src1_file,
unsigned int src1_index,
enum tgsi_file_type src2_file,
unsigned int src2_index,
enum tgsi_file_type src3_file,
unsigned int src3_index
);
struct tgsi_full_instruction vl_end(void);
#endif