Merge commit 'origin/master' into gallium-0.2
[mesa.git] / src / gallium / state_trackers / g3dvl / vl_r16snorm_mc_buf_shaders.inc
1 static int vlCreateVertexShaderIMB
2 (
3 struct vlR16SnormBufferedMC *mc
4 )
5 {
6 const unsigned int max_tokens = 50;
7
8 struct pipe_context *pipe;
9 struct pipe_shader_state vs;
10 struct tgsi_token *tokens;
11 struct tgsi_header *header;
12
13 struct tgsi_full_declaration decl;
14 struct tgsi_full_instruction inst;
15
16 unsigned int ti;
17 unsigned int i;
18
19 assert(mc);
20
21 pipe = mc->pipe;
22 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
23
24 /* Version */
25 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
26 /* Header */
27 header = (struct tgsi_header*)&tokens[1];
28 *header = tgsi_build_header();
29 /* Processor */
30 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
31
32 ti = 3;
33
34 /*
35 * decl i0 ; Vertex pos
36 * decl i1 ; Luma texcoords
37 * decl i2 ; Chroma Cb texcoords
38 * decl i3 ; Chroma Cr texcoords
39 */
40 for (i = 0; i < 4; i++)
41 {
42 decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
43 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
44 }
45
46 /*
47 * decl o0 ; Vertex pos
48 * decl o1 ; Luma texcoords
49 * decl o2 ; Chroma Cb texcoords
50 * decl o3 ; Chroma Cr texcoords
51 */
52 for (i = 0; i < 4; i++)
53 {
54 decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
55 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
56 }
57
58 /*
59 * mov o0, i0 ; Move input vertex pos to output
60 * mov o1, i1 ; Move input luma texcoords to output
61 * mov o2, i2 ; Move input chroma Cb texcoords to output
62 * mov o3, i3 ; Move input chroma Cr texcoords to output
63 */
64 for (i = 0; i < 4; ++i)
65 {
66 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
67 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
68 }
69
70 /* end */
71 inst = vl_end();
72 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
73
74 vs.tokens = tokens;
75 mc->i_vs = pipe->create_vs_state(pipe, &vs);
76 free(tokens);
77
78 return 0;
79 }
80
81 static int vlCreateFragmentShaderIMB
82 (
83 struct vlR16SnormBufferedMC *mc
84 )
85 {
86 const unsigned int max_tokens = 100;
87
88 struct pipe_context *pipe;
89 struct pipe_shader_state fs;
90 struct tgsi_token *tokens;
91 struct tgsi_header *header;
92
93 struct tgsi_full_declaration decl;
94 struct tgsi_full_instruction inst;
95
96 unsigned int ti;
97 unsigned int i;
98
99 assert(mc);
100
101 pipe = mc->pipe;
102 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
103
104 /* Version */
105 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
106 /* Header */
107 header = (struct tgsi_header*)&tokens[1];
108 *header = tgsi_build_header();
109 /* Processor */
110 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
111
112 ti = 3;
113
114 /*
115 * decl i0 ; Luma texcoords
116 * decl i1 ; Chroma Cb texcoords
117 * decl i2 ; Chroma Cr texcoords
118 */
119 for (i = 0; i < 3; ++i)
120 {
121 decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
122 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
123 }
124
125 /* decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm */
126 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
127 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
128
129 /* decl o0 ; Fragment color */
130 decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
131 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
132
133 /* decl t0, t1 */
134 decl = vl_decl_temps(0, 1);
135 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
136
137 /*
138 * decl s0 ; Sampler for luma texture
139 * decl s1 ; Sampler for chroma Cb texture
140 * decl s2 ; Sampler for chroma Cr texture
141 */
142 for (i = 0; i < 3; ++i)
143 {
144 decl = vl_decl_samplers(i, i);
145 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header,max_tokens - ti);
146 }
147
148 /*
149 * tex2d t1, i0, s0 ; Read texel from luma texture
150 * mov t0.x, t1.x ; Move luma sample into .x component
151 * tex2d t1, i1, s1 ; Read texel from chroma Cb texture
152 * mov t0.y, t1.x ; Move Cb sample into .y component
153 * tex2d t1, i2, s2 ; Read texel from chroma Cr texture
154 * mov t0.z, t1.x ; Move Cr sample into .z component
155 */
156 for (i = 0; i < 3; ++i)
157 {
158 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
159 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
160
161 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
162 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
163 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
164 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
165 inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
166 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
167 }
168
169 /* mul o0, t0, c0 ; Rescale texel to correct range */
170 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
171 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
172
173 /* end */
174 inst = vl_end();
175 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
176
177 fs.tokens = tokens;
178 mc->i_fs = pipe->create_fs_state(pipe, &fs);
179 free(tokens);
180
181 return 0;
182 }
183
184 static int vlCreateVertexShaderFramePMB
185 (
186 struct vlR16SnormBufferedMC *mc
187 )
188 {
189 const unsigned int max_tokens = 100;
190
191 struct pipe_context *pipe;
192 struct pipe_shader_state vs;
193 struct tgsi_token *tokens;
194 struct tgsi_header *header;
195
196 struct tgsi_full_declaration decl;
197 struct tgsi_full_instruction inst;
198
199 unsigned int ti;
200 unsigned int i;
201
202 assert(mc);
203
204 pipe = mc->pipe;
205 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
206
207 /* Version */
208 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
209 /* Header */
210 header = (struct tgsi_header*)&tokens[1];
211 *header = tgsi_build_header();
212 /* Processor */
213 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
214
215 ti = 3;
216
217 /*
218 * decl i0 ; Vertex pos
219 * decl i1 ; Luma texcoords
220 * decl i2 ; Chroma Cb texcoords
221 * decl i3 ; Chroma Cr texcoords
222 * decl i4 ; Ref surface top field texcoords
223 * decl i5 ; Ref surface bottom field texcoords (unused, packed in the same stream)
224 */
225 for (i = 0; i < 6; i++)
226 {
227 decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
228 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
229 }
230
231 /*
232 * decl o0 ; Vertex pos
233 * decl o1 ; Luma texcoords
234 * decl o2 ; Chroma Cb texcoords
235 * decl o3 ; Chroma Cr texcoords
236 * decl o4 ; Ref macroblock texcoords
237 */
238 for (i = 0; i < 5; i++)
239 {
240 decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
241 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
242 }
243
244 /*
245 * mov o0, i0 ; Move input vertex pos to output
246 * mov o1, i1 ; Move input luma texcoords to output
247 * mov o2, i2 ; Move input chroma Cb texcoords to output
248 * mov o3, i3 ; Move input chroma Cr texcoords to output
249 */
250 for (i = 0; i < 4; ++i)
251 {
252 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
253 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
254 }
255
256 /* add o4, i0, i4 ; Translate vertex pos by motion vec to form ref macroblock texcoords */
257 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, 4);
258 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
259
260 /* end */
261 inst = vl_end();
262 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
263
264 vs.tokens = tokens;
265 mc->p_vs[0] = pipe->create_vs_state(pipe, &vs);
266 free(tokens);
267
268 return 0;
269 }
270
271 static int vlCreateVertexShaderFieldPMB
272 (
273 struct vlR16SnormBufferedMC *mc
274 )
275 {
276 const unsigned int max_tokens = 100;
277
278 struct pipe_context *pipe;
279 struct pipe_shader_state vs;
280 struct tgsi_token *tokens;
281 struct tgsi_header *header;
282
283 struct tgsi_full_declaration decl;
284 struct tgsi_full_instruction inst;
285
286 unsigned int ti;
287 unsigned int i;
288
289 assert(mc);
290
291 pipe = mc->pipe;
292 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
293
294 /* Version */
295 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
296 /* Header */
297 header = (struct tgsi_header*)&tokens[1];
298 *header = tgsi_build_header();
299 /* Processor */
300 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
301
302 ti = 3;
303
304 /*
305 * decl i0 ; Vertex pos
306 * decl i1 ; Luma texcoords
307 * decl i2 ; Chroma Cb texcoords
308 * decl i3 ; Chroma Cr texcoords
309 * decl i4 ; Ref macroblock top field texcoords
310 * decl i5 ; Ref macroblock bottom field texcoords
311 */
312 for (i = 0; i < 6; i++)
313 {
314 decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
315 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
316 }
317
318 /* decl c0 ; Render target dimensions */
319 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
320 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
321
322 /*
323 * decl o0 ; Vertex pos
324 * decl o1 ; Luma texcoords
325 * decl o2 ; Chroma Cb texcoords
326 * decl o3 ; Chroma Cr texcoords
327 * decl o4 ; Ref macroblock top field texcoords
328 * decl o5 ; Ref macroblock bottom field texcoords
329 * decl o6 ; Denormalized vertex pos
330 */
331 for (i = 0; i < 7; i++)
332 {
333 decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
334 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
335 }
336
337 /*
338 * mov o0, i0 ; Move input vertex pos to output
339 * mov o1, i1 ; Move input luma texcoords to output
340 * mov o2, i2 ; Move input chroma Cb texcoords to output
341 * mov o3, i3 ; Move input chroma Cr texcoords to output
342 */
343 for (i = 0; i < 4; ++i)
344 {
345 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
346 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
347 }
348
349 /*
350 * add o4, i0, i4 ; Translate vertex pos by motion vec to form top field macroblock texcoords
351 * add o5, i0, i5 ; Translate vertex pos by motion vec to form bottom field macroblock texcoords
352 */
353 for (i = 0; i < 2; ++i)
354 {
355 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, i + 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, i + 4);
356 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
357 }
358
359 /* mul o6, i0, c0 ; Denorm vertex pos */
360 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_OUTPUT, 6, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
361 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
362
363 /* end */
364 inst = vl_end();
365 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
366
367 vs.tokens = tokens;
368 mc->p_vs[1] = pipe->create_vs_state(pipe, &vs);
369 free(tokens);
370
371 return 0;
372 }
373
374 static int vlCreateFragmentShaderFramePMB
375 (
376 struct vlR16SnormBufferedMC *mc
377 )
378 {
379 const unsigned int max_tokens = 100;
380
381 struct pipe_context *pipe;
382 struct pipe_shader_state fs;
383 struct tgsi_token *tokens;
384 struct tgsi_header *header;
385
386 struct tgsi_full_declaration decl;
387 struct tgsi_full_instruction inst;
388
389 unsigned int ti;
390 unsigned int i;
391
392 assert(mc);
393
394 pipe = mc->pipe;
395 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
396
397 /* Version */
398 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
399 /* Header */
400 header = (struct tgsi_header*)&tokens[1];
401 *header = tgsi_build_header();
402 /* Processor */
403 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
404
405 ti = 3;
406
407 /*
408 * decl i0 ; Luma texcoords
409 * decl i1 ; Chroma Cb texcoords
410 * decl i2 ; Chroma Cr texcoords
411 * decl i3 ; Ref macroblock texcoords
412 */
413 for (i = 0; i < 4; ++i)
414 {
415 decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
416 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
417 }
418
419 /* decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm */
420 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
421 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
422
423 /* decl o0 ; Fragment color */
424 decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
425 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
426
427 /* decl t0, t1 */
428 decl = vl_decl_temps(0, 1);
429 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
430
431 /*
432 * decl s0 ; Sampler for luma texture
433 * decl s1 ; Sampler for chroma Cb texture
434 * decl s2 ; Sampler for chroma Cr texture
435 * decl s3 ; Sampler for ref surface texture
436 */
437 for (i = 0; i < 4; ++i)
438 {
439 decl = vl_decl_samplers(i, i);
440 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
441 }
442
443 /*
444 * tex2d t1, i0, s0 ; Read texel from luma texture
445 * mov t0.x, t1.x ; Move luma sample into .x component
446 * tex2d t1, i1, s1 ; Read texel from chroma Cb texture
447 * mov t0.y, t1.x ; Move Cb sample into .y component
448 * tex2d t1, i2, s2 ; Read texel from chroma Cr texture
449 * mov t0.z, t1.x ; Move Cr sample into .z component
450 */
451 for (i = 0; i < 3; ++i)
452 {
453 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
454 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
455
456 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
457 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
458 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
459 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
460 inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
461 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
462 }
463
464 /* mul t0, t0, c0 ; Rescale texel to correct range */
465 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
466 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
467
468 /* tex2d t1, i3, s3 ; Read texel from ref macroblock */
469 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, 3, TGSI_FILE_SAMPLER, 3);
470 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
471
472 /* add o0, t0, t1 ; Add ref and differential to form final output */
473 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
474 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
475
476 /* end */
477 inst = vl_end();
478 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
479
480 fs.tokens = tokens;
481 mc->p_fs[0] = pipe->create_fs_state(pipe, &fs);
482 free(tokens);
483
484 return 0;
485 }
486
487 static int vlCreateFragmentShaderFieldPMB
488 (
489 struct vlR16SnormBufferedMC *mc
490 )
491 {
492 const unsigned int max_tokens = 200;
493
494 struct pipe_context *pipe;
495 struct pipe_shader_state fs;
496 struct tgsi_token *tokens;
497 struct tgsi_header *header;
498
499 struct tgsi_full_declaration decl;
500 struct tgsi_full_instruction inst;
501
502 unsigned int ti;
503 unsigned int i;
504
505 assert(mc);
506
507 pipe = mc->pipe;
508 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
509
510 /* Version */
511 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
512 /* Header */
513 header = (struct tgsi_header*)&tokens[1];
514 *header = tgsi_build_header();
515 /* Processor */
516 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
517
518 ti = 3;
519
520 /*
521 * decl i0 ; Luma texcoords
522 * decl i1 ; Chroma Cb texcoords
523 * decl i2 ; Chroma Cr texcoords
524 * decl i3 ; Ref macroblock top field texcoords
525 * decl i4 ; Ref macroblock bottom field texcoords
526 * decl i5 ; Denormalized vertex pos
527 */
528 for (i = 0; i < 6; ++i)
529 {
530 decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
531 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
532 }
533
534 /*
535 * decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm
536 * decl c1 ; Constants 1/2 & 2 in .x, .y channels for Y-mod-2 top/bottom field selection
537 */
538 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 1);
539 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
540
541 /* decl o0 ; Fragment color */
542 decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
543 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
544
545 /* decl t0-t4 */
546 decl = vl_decl_temps(0, 4);
547 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
548
549 /*
550 * decl s0 ; Sampler for luma texture
551 * decl s1 ; Sampler for chroma Cb texture
552 * decl s2 ; Sampler for chroma Cr texture
553 * decl s3 ; Sampler for ref surface texture
554 */
555 for (i = 0; i < 4; ++i)
556 {
557 decl = vl_decl_samplers(i, i);
558 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
559 }
560
561 /*
562 * tex2d t1, i0, s0 ; Read texel from luma texture
563 * mov t0.x, t1.x ; Move luma sample into .x component
564 * tex2d t1, i1, s1 ; Read texel from chroma Cb texture
565 * mov t0.y, t1.x ; Move Cb sample into .y component
566 * tex2d t1, i2, s2 ; Read texel from chroma Cr texture
567 * mov t0.z, t1.x ; Move Cr sample into .z component
568 */
569 for (i = 0; i < 3; ++i)
570 {
571 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
572 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
573
574 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
575 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
576 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
577 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
578 inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
579 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
580 }
581
582 /* mul t0, t0, c0 ; Rescale texel to correct range */
583 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
584 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
585
586 /*
587 * tex2d t1, i3, s3 ; Read texel from ref macroblock top field
588 * tex2d t2, i4, s3 ; Read texel from ref macroblock bottom field
589 */
590 for (i = 0; i < 2; ++i)
591 {
592 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, i + 1, TGSI_FILE_INPUT, i + 3, TGSI_FILE_SAMPLER, 3);
593 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
594 }
595
596 /* XXX: Pos values off by 0.5? */
597 /* sub t4, i5.y, c1.x ; Sub 0.5 from denormalized pos */
598 inst = vl_inst3(TGSI_OPCODE_SUB, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_INPUT, 5, TGSI_FILE_CONSTANT, 1);
599 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_Y;
600 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_Y;
601 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_Y;
602 inst.FullSrcRegisters[0].SrcRegister.SwizzleW = TGSI_SWIZZLE_Y;
603 inst.FullSrcRegisters[1].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
604 inst.FullSrcRegisters[1].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
605 inst.FullSrcRegisters[1].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
606 inst.FullSrcRegisters[1].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
607 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
608
609 /* mul t3, t4, c1.x ; Multiply pos Y-coord by 1/2 */
610 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_CONSTANT, 1);
611 inst.FullSrcRegisters[1].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
612 inst.FullSrcRegisters[1].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
613 inst.FullSrcRegisters[1].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
614 inst.FullSrcRegisters[1].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
615 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
616
617 /* floor t3, t3 ; Get rid of fractional part */
618 inst = vl_inst2(TGSI_OPCODE_FLOOR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
619 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
620
621 /* mul t3, t3, c1.y ; Multiply by 2 */
622 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_CONSTANT, 1);
623 inst.FullSrcRegisters[1].SrcRegister.SwizzleX = TGSI_SWIZZLE_Y;
624 inst.FullSrcRegisters[1].SrcRegister.SwizzleY = TGSI_SWIZZLE_Y;
625 inst.FullSrcRegisters[1].SrcRegister.SwizzleZ = TGSI_SWIZZLE_Y;
626 inst.FullSrcRegisters[1].SrcRegister.SwizzleW = TGSI_SWIZZLE_Y;
627 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
628
629 /* sub t3, t4, t3 ; Subtract from original Y to get Y % 2 */
630 inst = vl_inst3(TGSI_OPCODE_SUB, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 3);
631 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
632
633 /* TODO: Move to conditional tex fetch on t3 instead of lerp */
634 /* lerp t1, t3, t1, t2 ; Choose between top and bottom fields based on Y % 2 */
635 inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
636 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
637
638 /* add o0, t0, t1 ; Add ref and differential to form final output */
639 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
640 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
641
642 /* end */
643 inst = vl_end();
644 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
645
646 fs.tokens = tokens;
647 mc->p_fs[1] = pipe->create_fs_state(pipe, &fs);
648 free(tokens);
649
650 return 0;
651 }
652
653 static int vlCreateVertexShaderFrameBMB
654 (
655 struct vlR16SnormBufferedMC *mc
656 )
657 {
658 const unsigned int max_tokens = 100;
659
660 struct pipe_context *pipe;
661 struct pipe_shader_state vs;
662 struct tgsi_token *tokens;
663 struct tgsi_header *header;
664
665 struct tgsi_full_declaration decl;
666 struct tgsi_full_instruction inst;
667
668 unsigned int ti;
669 unsigned int i;
670
671 assert(mc);
672
673 pipe = mc->pipe;
674 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
675
676 /* Version */
677 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
678 /* Header */
679 header = (struct tgsi_header*)&tokens[1];
680 *header = tgsi_build_header();
681 /* Processor */
682 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
683
684 ti = 3;
685
686 /*
687 * decl i0 ; Vertex pos
688 * decl i1 ; Luma texcoords
689 * decl i2 ; Chroma Cb texcoords
690 * decl i3 ; Chroma Cr texcoords
691 * decl i4 ; First ref macroblock top field texcoords
692 * decl i5 ; First ref macroblock bottom field texcoords (unused, packed in the same stream)
693 * decl i6 ; Second ref macroblock top field texcoords
694 * decl i7 ; Second ref macroblock bottom field texcoords (unused, packed in the same stream)
695 */
696 for (i = 0; i < 8; i++)
697 {
698 decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
699 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
700 }
701
702 /*
703 * decl o0 ; Vertex pos
704 * decl o1 ; Luma texcoords
705 * decl o2 ; Chroma Cb texcoords
706 * decl o3 ; Chroma Cr texcoords
707 * decl o4 ; First ref macroblock texcoords
708 * decl o5 ; Second ref macroblock texcoords
709 */
710 for (i = 0; i < 6; i++)
711 {
712 decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
713 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
714 }
715
716 /*
717 * mov o0, i0 ; Move input vertex pos to output
718 * mov o1, i1 ; Move input luma texcoords to output
719 * mov o2, i2 ; Move input chroma Cb texcoords to output
720 * mov o3, i3 ; Move input chroma Cr texcoords to output
721 */
722 for (i = 0; i < 4; ++i)
723 {
724 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
725 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
726 }
727
728 /*
729 * add o4, i0, i4 ; Translate vertex pos by motion vec to form first ref macroblock texcoords
730 * add o5, i0, i6 ; Translate vertex pos by motion vec to form second ref macroblock texcoords
731 */
732 for (i = 0; i < 2; ++i)
733 {
734 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, i + 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, (i + 2) * 2);
735 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
736 }
737
738 /* end */
739 inst = vl_end();
740 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
741
742 vs.tokens = tokens;
743 mc->b_vs[0] = pipe->create_vs_state(pipe, &vs);
744 free(tokens);
745
746 return 0;
747 }
748
749 static int vlCreateVertexShaderFieldBMB
750 (
751 struct vlR16SnormBufferedMC *mc
752 )
753 {
754 const unsigned int max_tokens = 100;
755
756 struct pipe_context *pipe;
757 struct pipe_shader_state vs;
758 struct tgsi_token *tokens;
759 struct tgsi_header *header;
760
761 struct tgsi_full_declaration decl;
762 struct tgsi_full_instruction inst;
763
764 unsigned int ti;
765 unsigned int i;
766
767 assert(mc);
768
769 pipe = mc->pipe;
770 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
771
772 /* Version */
773 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
774 /* Header */
775 header = (struct tgsi_header*)&tokens[1];
776 *header = tgsi_build_header();
777 /* Processor */
778 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
779
780 ti = 3;
781
782 /*
783 * decl i0 ; Vertex pos
784 * decl i1 ; Luma texcoords
785 * decl i2 ; Chroma Cb texcoords
786 * decl i3 ; Chroma Cr texcoords
787 * decl i4 ; First ref macroblock top field texcoords
788 * decl i5 ; First ref macroblock bottom field texcoords
789 * decl i6 ; Second ref macroblock top field texcoords
790 * decl i7 ; Second ref macroblock bottom field texcoords
791 */
792 for (i = 0; i < 8; i++)
793 {
794 decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
795 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
796 }
797
798 /* decl c0 ; Render target dimensions */
799 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
800 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
801
802 /*
803 * decl o0 ; Vertex pos
804 * decl o1 ; Luma texcoords
805 * decl o2 ; Chroma Cb texcoords
806 * decl o3 ; Chroma Cr texcoords
807 * decl o4 ; First ref macroblock top field texcoords
808 * decl o5 ; First ref macroblock Bottom field texcoords
809 * decl o6 ; Second ref macroblock top field texcoords
810 * decl o7 ; Second ref macroblock Bottom field texcoords
811 * decl o8 ; Denormalized vertex pos
812 */
813 for (i = 0; i < 9; i++)
814 {
815 decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
816 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
817 }
818
819 /* decl t0, t1 */
820 decl = vl_decl_temps(0, 1);
821 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
822
823 /*
824 * mov o0, i0 ; Move input vertex pos to output
825 * mov o1, i1 ; Move input luma texcoords to output
826 * mov o2, i2 ; Move input chroma Cb texcoords to output
827 * mov o3, i3 ; Move input chroma Cr texcoords to output
828 */
829 for (i = 0; i < 4; ++i)
830 {
831 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
832 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
833 }
834
835 /*
836 * add o4, i0, i4 ; Translate vertex pos by motion vec to form first top field macroblock texcoords
837 * add o5, i0, i5 ; Translate vertex pos by motion vec to form first bottom field macroblock texcoords
838 * add o6, i0, i6 ; Translate vertex pos by motion vec to form second top field macroblock texcoords
839 * add o7, i0, i7 ; Translate vertex pos by motion vec to form second bottom field macroblock texcoords
840 */
841 for (i = 0; i < 4; ++i)
842 {
843 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, i + 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, i + 4);
844 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
845 }
846
847 /* mul o8, i0, c0 ; Denorm vertex pos */
848 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_OUTPUT, 8, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
849 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
850
851 /* end */
852 inst = vl_end();
853 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
854
855 vs.tokens = tokens;
856 mc->b_vs[1] = pipe->create_vs_state(pipe, &vs);
857 free(tokens);
858
859 return 0;
860 }
861
862 static int vlCreateFragmentShaderFrameBMB
863 (
864 struct vlR16SnormBufferedMC *mc
865 )
866 {
867 const unsigned int max_tokens = 100;
868
869 struct pipe_context *pipe;
870 struct pipe_shader_state fs;
871 struct tgsi_token *tokens;
872 struct tgsi_header *header;
873
874 struct tgsi_full_declaration decl;
875 struct tgsi_full_instruction inst;
876
877 unsigned int ti;
878 unsigned int i;
879
880 assert(mc);
881
882 pipe = mc->pipe;
883 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
884
885 /* Version */
886 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
887 /* Header */
888 header = (struct tgsi_header*)&tokens[1];
889 *header = tgsi_build_header();
890 /* Processor */
891 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
892
893 ti = 3;
894
895 /*
896 * decl i0 ; Luma texcoords
897 * decl i1 ; Chroma Cb texcoords
898 * decl i2 ; Chroma Cr texcoords
899 * decl i3 ; First ref macroblock texcoords
900 * decl i4 ; Second ref macroblock texcoords
901 */
902 for (i = 0; i < 5; ++i)
903 {
904 decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
905 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
906 }
907
908 /*
909 * decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm
910 * decl c1 ; Constant 1/2 in .x channel to use as weight to blend past and future texels
911 */
912 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 1);
913 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
914
915 /* decl o0 ; Fragment color */
916 decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
917 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
918
919 /* decl t0-t2 */
920 decl = vl_decl_temps(0, 2);
921 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
922
923 /*
924 * decl s0 ; Sampler for luma texture
925 * decl s1 ; Sampler for chroma Cb texture
926 * decl s2 ; Sampler for chroma Cr texture
927 * decl s3 ; Sampler for first ref surface texture
928 * decl s4 ; Sampler for second ref surface texture
929 */
930 for (i = 0; i < 5; ++i)
931 {
932 decl = vl_decl_samplers(i, i);
933 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
934 }
935
936 /*
937 * tex2d t1, i0, s0 ; Read texel from luma texture
938 * mov t0.x, t1.x ; Move luma sample into .x component
939 * tex2d t1, i1, s1 ; Read texel from chroma Cb texture
940 * mov t0.y, t1.x ; Move Cb sample into .y component
941 * tex2d t1, i2, s2 ; Read texel from chroma Cr texture
942 * mov t0.z, t1.x ; Move Cr sample into .z component
943 */
944 for (i = 0; i < 3; ++i)
945 {
946 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
947 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
948
949 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
950 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
951 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
952 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
953 inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
954 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
955 }
956
957 /* mul t0, t0, c0 ; Rescale texel to correct range */
958 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
959 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
960
961 /*
962 * tex2d t1, i3, s3 ; Read texel from first ref macroblock
963 * tex2d t2, i4, s4 ; Read texel from second ref macroblock
964 */
965 for (i = 0; i < 2; ++i)
966 {
967 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, i + 1, TGSI_FILE_INPUT, i + 3, TGSI_FILE_SAMPLER, i + 3);
968 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
969 }
970
971 /* lerp t1, c1.x, t1, t2 ; Blend past and future texels */
972 inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
973 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
974 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
975 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
976 inst.FullSrcRegisters[0].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
977 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
978
979 /* add o0, t0, t1 ; Add past/future ref and differential to form final output */
980 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
981 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
982
983 /* end */
984 inst = vl_end();
985 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
986
987 fs.tokens = tokens;
988 mc->b_fs[0] = pipe->create_fs_state(pipe, &fs);
989 free(tokens);
990
991 return 0;
992 }
993
994 static int vlCreateFragmentShaderFieldBMB
995 (
996 struct vlR16SnormBufferedMC *mc
997 )
998 {
999 const unsigned int max_tokens = 200;
1000
1001 struct pipe_context *pipe;
1002 struct pipe_shader_state fs;
1003 struct tgsi_token *tokens;
1004 struct tgsi_header *header;
1005
1006 struct tgsi_full_declaration decl;
1007 struct tgsi_full_instruction inst;
1008
1009 unsigned int ti;
1010 unsigned int i;
1011
1012 assert(mc);
1013
1014 pipe = mc->pipe;
1015 tokens = (struct tgsi_token*)malloc(max_tokens * sizeof(struct tgsi_token));
1016
1017 /* Version */
1018 *(struct tgsi_version*)&tokens[0] = tgsi_build_version();
1019 /* Header */
1020 header = (struct tgsi_header*)&tokens[1];
1021 *header = tgsi_build_header();
1022 /* Processor */
1023 *(struct tgsi_processor*)&tokens[2] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
1024
1025 ti = 3;
1026
1027 /*
1028 * decl i0 ; Luma texcoords
1029 * decl i1 ; Chroma Cb texcoords
1030 * decl i2 ; Chroma Cr texcoords
1031 * decl i3 ; First ref macroblock top field texcoords
1032 * decl i4 ; First ref macroblock bottom field texcoords
1033 * decl i5 ; Second ref macroblock top field texcoords
1034 * decl i6 ; Second ref macroblock bottom field texcoords
1035 * decl i7 ; Denormalized vertex pos
1036 */
1037 for (i = 0; i < 8; ++i)
1038 {
1039 decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
1040 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
1041 }
1042
1043 /*
1044 * decl c0 ; Scaling factor, rescales 16-bit snorm to 9-bit snorm
1045 * decl c1 ; Constants 1/2 & 2 in .x, .y channels to use as weight to blend past and future texels
1046 * ; and for Y-mod-2 top/bottom field selection
1047 */
1048 decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 1);
1049 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
1050
1051 /* decl o0 ; Fragment color */
1052 decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
1053 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
1054
1055 /* decl t0-t5 */
1056 decl = vl_decl_temps(0, 5);
1057 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
1058
1059 /*
1060 * decl s0 ; Sampler for luma texture
1061 * decl s1 ; Sampler for chroma Cb texture
1062 * decl s2 ; Sampler for chroma Cr texture
1063 * decl s3 ; Sampler for first ref surface texture
1064 * decl s4 ; Sampler for second ref surface texture
1065 */
1066 for (i = 0; i < 5; ++i)
1067 {
1068 decl = vl_decl_samplers(i, i);
1069 ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
1070 }
1071
1072 /*
1073 * tex2d t1, i0, s0 ; Read texel from luma texture
1074 * mov t0.x, t1.x ; Move luma sample into .x component
1075 * tex2d t1, i1, s1 ; Read texel from chroma Cb texture
1076 * mov t0.y, t1.x ; Move Cb sample into .y component
1077 * tex2d t1, i2, s2 ; Read texel from chroma Cr texture
1078 * mov t0.z, t1.x ; Move Cr sample into .z component
1079 */
1080 for (i = 0; i < 3; ++i)
1081 {
1082 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
1083 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1084
1085 inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
1086 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
1087 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
1088 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
1089 inst.FullDstRegisters[0].DstRegister.WriteMask = TGSI_WRITEMASK_X << i;
1090 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1091 }
1092
1093 /* mul t0, t0, c0 ; Rescale texel to correct range */
1094 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
1095 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1096
1097 /* XXX: Pos values off by 0.5? */
1098 /* sub t4, i7.y, c1.x ; Sub 0.5 from denormalized pos */
1099 inst = vl_inst3(TGSI_OPCODE_SUB, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_INPUT, 7, TGSI_FILE_CONSTANT, 1);
1100 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_Y;
1101 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_Y;
1102 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_Y;
1103 inst.FullSrcRegisters[0].SrcRegister.SwizzleW = TGSI_SWIZZLE_Y;
1104 inst.FullSrcRegisters[1].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
1105 inst.FullSrcRegisters[1].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
1106 inst.FullSrcRegisters[1].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
1107 inst.FullSrcRegisters[1].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
1108 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1109
1110 /* mul t3, t4, c1.x ; Multiply pos Y-coord by 1/2 */
1111 inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_CONSTANT, 1);
1112 inst.FullSrcRegisters[1].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
1113 inst.FullSrcRegisters[1].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
1114 inst.FullSrcRegisters[1].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
1115 inst.FullSrcRegisters[1].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
1116 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1117
1118 /* floor t3, t3 ; Get rid of fractional part */
1119 inst = vl_inst2(TGSI_OPCODE_FLOOR, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3);
1120 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1121
1122 /* mul t3, t3, c1.y ; Multiply by 2 */
1123 inst = vl_inst3( TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_CONSTANT, 1);
1124 inst.FullSrcRegisters[1].SrcRegister.SwizzleX = TGSI_SWIZZLE_Y;
1125 inst.FullSrcRegisters[1].SrcRegister.SwizzleY = TGSI_SWIZZLE_Y;
1126 inst.FullSrcRegisters[1].SrcRegister.SwizzleZ = TGSI_SWIZZLE_Y;
1127 inst.FullSrcRegisters[1].SrcRegister.SwizzleW = TGSI_SWIZZLE_Y;
1128 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1129
1130 /* sub t3, t4, t3 ; Subtract from original Y to get Y % 2 */
1131 inst = vl_inst3(TGSI_OPCODE_SUB, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 3);
1132 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1133
1134 /*
1135 * tex2d t1, i3, s3 ; Read texel from past ref macroblock top field
1136 * tex2d t2, i4, s3 ; Read texel from past ref macroblock bottom field
1137 */
1138 for (i = 0; i < 2; ++i)
1139 {
1140 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, i + 1, TGSI_FILE_INPUT, i + 3, TGSI_FILE_SAMPLER, 3);
1141 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1142 }
1143
1144 /* TODO: Move to conditional tex fetch on t3 instead of lerp */
1145 /* lerp t1, t3, t1, t2 ; Choose between top and bottom fields based on Y % 2 */
1146 inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
1147 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1148
1149 /*
1150 * tex2d t4, i5, s4 ; Read texel from future ref macroblock top field
1151 * tex2d t5, i6, s4 ; Read texel from future ref macroblock bottom field
1152 */
1153 for (i = 0; i < 2; ++i)
1154 {
1155 inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, i + 4, TGSI_FILE_INPUT, i + 5, TGSI_FILE_SAMPLER, 4);
1156 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1157 }
1158
1159 /* TODO: Move to conditional tex fetch on t3 instead of lerp */
1160 /* lerp t2, t3, t4, t5 ; Choose between top and bottom fields based on Y % 2 */
1161 inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 2, TGSI_FILE_TEMPORARY, 3, TGSI_FILE_TEMPORARY, 4, TGSI_FILE_TEMPORARY, 5);
1162 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1163
1164 /* lerp t1, c1.x, t1, t2 ; Blend past and future texels */
1165 inst = vl_inst4(TGSI_OPCODE_LERP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
1166 inst.FullSrcRegisters[0].SrcRegister.SwizzleX = TGSI_SWIZZLE_X;
1167 inst.FullSrcRegisters[0].SrcRegister.SwizzleY = TGSI_SWIZZLE_X;
1168 inst.FullSrcRegisters[0].SrcRegister.SwizzleZ = TGSI_SWIZZLE_X;
1169 inst.FullSrcRegisters[0].SrcRegister.SwizzleW = TGSI_SWIZZLE_X;
1170 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1171
1172 /* add o0, t0, t1 ; Add past/future ref and differential to form final output */
1173 inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
1174 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1175
1176 /* end */
1177 inst = vl_end();
1178 ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
1179
1180 fs.tokens = tokens;
1181 mc->b_fs[1] = pipe->create_fs_state(pipe, &fs);
1182 free(tokens);
1183
1184 return 0;
1185 }