← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/gallium/state_trackers/xorg/xorg_renderer.c

  • Committer: Package Import Robot
  • Author(s): Timo Aaltonen
  • Date: 2012-08-23 15:37:30 UTC
  • mfrom: (1.7.6)
  • Revision ID: package-import@ubuntu.com-20120823153730-c499sefj7btu4386
Tags: 9.0~git20120821.c1114c61-0ubuntu1
https://launchpad.net/bugs/1009089
* Merge from unreleased debian git.
  - Includes support for ATI Trinity PCI IDs (LP: #1009089)
* rules, control, libgl1-mesa-swx11*: Remove swx11 support.
* Refresh patches:
  - drop 115_llvm_dynamic_linking.diff,
    117_nullptr_check_in_query_version.patch, and
    118_glsl_initialize_samplers.patch, all upstream
  - disable 116_use_shared_galliumcore.diff until it's reviewed and
    reworked to apply
* not-installed, libegl1-mesa-drivers-install.linux.in: Updated to
  match the single-pass build.
* libgl1-mesa-dri.*install.in: Drop libglsl.so, it's included in
  libdricore.so now.
* rules: Don't disable GLU on the common flags, we need to build it
  on the dri target.
* libglu*install.in: Fix the source file paths to match the build target.
  Drop the static lib from -dev since only shared libs get built.
* libgl1-mesa-dev.install.in: Fix the source file paths to match the
  build target.
* libgl1-mesa-dri.install.linux.in: Don't try to install libgallium.so,
  which isn't built yet.
* rules: Enable llvmpipe on armhf to see if it works or not.
* rules: Remove bin/install-sh on clean, and don't create a symlink for
  it.
* control: Add Pre-Depends on dpkg-dev due to the binaries using xz
  compression.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/state_trackers/xorg/xorg_renderer.c
42
42
   }
43
43
}
44
44
 
45
 
static INLINE struct pipe_resource *
46
 
renderer_buffer_create(struct xorg_renderer *r)
47
 
{
48
 
   struct pipe_resource *buf =
49
 
      pipe_user_buffer_create(r->pipe->screen,
50
 
                              r->buffer,
51
 
                              sizeof(float)*
52
 
                              r->buffer_size,
53
 
/* XXX was: PIPE_BUFFER_USAGE_PIXEL/PIPE_BUFFER_USAGE_GPU_WRITE even though this is a vertex buffer??? */
54
 
                              PIPE_BIND_VERTEX_BUFFER);
55
 
   r->buffer_size = 0;
56
 
 
57
 
   return buf;
58
 
}
59
 
 
60
45
static INLINE void
61
46
renderer_draw(struct xorg_renderer *r)
62
47
{
63
 
   struct pipe_context *pipe = r->pipe;
64
 
   struct pipe_resource *buf = 0;
65
48
   int num_verts = r->buffer_size/(r->attrs_per_vertex * NUM_COMPONENTS);
66
49
 
67
50
   if (!r->buffer_size)
68
51
      return;
69
52
 
70
 
   buf = renderer_buffer_create(r);
71
 
 
72
 
 
73
 
   if (buf) {
74
 
      cso_set_vertex_elements(r->cso, r->attrs_per_vertex, r->velems);
75
 
 
76
 
      util_draw_vertex_buffer(pipe, r->cso, buf, 0,
77
 
                              PIPE_PRIM_QUADS,
78
 
                              num_verts,  /* verts */
79
 
                              r->attrs_per_vertex); /* attribs/vert */
80
 
 
81
 
      pipe_resource_reference(&buf, NULL);
82
 
   }
 
53
   cso_set_vertex_elements(r->cso, r->attrs_per_vertex, r->velems);
 
54
   util_draw_user_vertex_buffer(r->cso, r->buffer, PIPE_PRIM_QUADS,
 
55
                                num_verts, r->attrs_per_vertex);
 
56
 
 
57
   r->buffer_size = 0;
83
58
}
84
59
 
85
60
static INLINE void
238
213
                 struct pipe_resource *mask,
239
214
                 float *src_matrix, float *mask_matrix)
240
215
{
241
 
   float src_s0, src_t0, src_s1, src_t1;
242
 
   float mask_s0, mask_t0, mask_s1, mask_t1;
243
 
   float spt0[2], spt1[2];
244
 
   float mpt0[2], mpt1[2];
 
216
   float src_s0, src_t0, src_s1, src_t1, src_s2, src_t2, src_s3, src_t3;
 
217
   float mask_s0, mask_t0, mask_s1, mask_t1, mask_s2, mask_t2, mask_s3, mask_t3;
 
218
   float spt0[2], spt1[2], spt2[2], spt3[2];
 
219
   float mpt0[2], mpt1[2], mpt2[2], mpt3[2];
245
220
 
246
221
   spt0[0] = srcX;
247
222
   spt0[1] = srcY;
248
 
   spt1[0] = srcX + width;
249
 
   spt1[1] = srcY + height;
 
223
   spt1[0] = (srcX + width);
 
224
   spt1[1] = srcY;
 
225
   spt2[0] = (srcX + width);
 
226
   spt2[1] = (srcY + height);
 
227
   spt3[0] = srcX;
 
228
   spt3[1] = (srcY + height);
250
229
 
251
230
   mpt0[0] = maskX;
252
231
   mpt0[1] = maskY;
253
 
   mpt1[0] = maskX + width;
254
 
   mpt1[1] = maskY + height;
 
232
   mpt1[0] = (maskX + width);
 
233
   mpt1[1] = maskY;
 
234
   mpt2[0] = (maskX + width);
 
235
   mpt2[1] = (maskY + height);
 
236
   mpt3[0] = maskX;
 
237
   mpt3[1] = (maskY + height);
255
238
 
256
239
   if (src_matrix) {
257
240
      map_point(src_matrix, spt0[0], spt0[1], &spt0[0], &spt0[1]);
258
241
      map_point(src_matrix, spt1[0], spt1[1], &spt1[0], &spt1[1]);
 
242
      map_point(src_matrix, spt2[0], spt2[1], &spt2[0], &spt2[1]);
 
243
      map_point(src_matrix, spt3[0], spt3[1], &spt3[0], &spt3[1]);
259
244
   }
260
245
 
261
246
   if (mask_matrix) {
262
247
      map_point(mask_matrix, mpt0[0], mpt0[1], &mpt0[0], &mpt0[1]);
263
248
      map_point(mask_matrix, mpt1[0], mpt1[1], &mpt1[0], &mpt1[1]);
 
249
      map_point(mask_matrix, mpt2[0], mpt2[1], &mpt2[0], &mpt2[1]);
 
250
      map_point(mask_matrix, mpt3[0], mpt3[1], &mpt3[0], &mpt3[1]);
264
251
   }
265
252
 
266
 
   src_s0 = spt0[0] / src->width0;
267
 
   src_t0 = spt0[1] / src->height0;
268
 
   src_s1 = spt1[0] / src->width0;
269
 
   src_t1 = spt1[1] / src->height0;
 
253
   src_s0 =  spt0[0] / src->width0;
 
254
   src_s1 =  spt1[0] / src->width0;
 
255
   src_s2 =  spt2[0] / src->width0;
 
256
   src_s3 =  spt3[0] / src->width0;
 
257
   src_t0 =  spt0[1] / src->height0;
 
258
   src_t1 =  spt1[1] / src->height0;
 
259
   src_t2 =  spt2[1] / src->height0;
 
260
   src_t3 =  spt3[1] / src->height0;
270
261
 
271
 
   mask_s0 = mpt0[0] / mask->width0;
272
 
   mask_t0 = mpt0[1] / mask->height0;
273
 
   mask_s1 = mpt1[0] / mask->width0;
274
 
   mask_t1 = mpt1[1] / mask->height0;
 
262
   mask_s0 =  mpt0[0] / mask->width0;
 
263
   mask_s1 =  mpt1[0] / mask->width0;
 
264
   mask_s2 =  mpt2[0] / mask->width0;
 
265
   mask_s3 =  mpt3[0] / mask->width0;
 
266
   mask_t0 =  mpt0[1] / mask->height0;
 
267
   mask_t1 =  mpt1[1] / mask->height0;
 
268
   mask_t2 =  mpt2[1] / mask->height0;
 
269
   mask_t3 =  mpt3[1] / mask->height0;
275
270
 
276
271
   /* 1st vertex */
277
272
   add_vertex_2tex(r, dstX, dstY,
278
273
                   src_s0, src_t0, mask_s0, mask_t0);
279
274
   /* 2nd vertex */
280
275
   add_vertex_2tex(r, dstX + width, dstY,
281
 
                   src_s1, src_t0, mask_s1, mask_t0);
 
276
                   src_s1, src_t1, mask_s1, mask_t1);
282
277
   /* 3rd vertex */
283
278
   add_vertex_2tex(r, dstX + width, dstY + height,
284
 
                   src_s1, src_t1, mask_s1, mask_t1);
 
279
                   src_s2, src_t2, mask_s2, mask_t2);
285
280
   /* 4th vertex */
286
281
   add_vertex_2tex(r, dstX, dstY + height,
287
 
                   src_s0, src_t1, mask_s0, mask_t1);
 
282
                   src_s3, src_t3, mask_s3, mask_t3);
288
283
}
289
284
 
290
 
static struct pipe_resource *
 
285
static void
291
286
setup_vertex_data_yuv(struct xorg_renderer *r,
292
287
                      float srcX, float srcY, float srcW, float srcH,
293
288
                      float dstX, float dstY, float dstW, float dstH,
317
312
   /* 4th vertex */
318
313
   add_vertex_1tex(r, dstX, dstY + dstH,
319
314
                   s0, t1);
320
 
 
321
 
   return renderer_buffer_create(r);
322
315
}
323
316
 
324
317
 
437
430
      pipe_buffer_write(r->pipe, *cbuf,
438
431
                        0, param_bytes, params);
439
432
   }
440
 
   r->pipe->set_constant_buffer(r->pipe, shader_type, 0, *cbuf);
441
 
}
442
 
 
443
 
 
444
 
void renderer_copy_prepare(struct xorg_renderer *r,
445
 
                           struct pipe_surface *dst_surface,
446
 
                           struct pipe_resource *src_texture)
447
 
{
448
 
   struct pipe_context *pipe = r->pipe;
449
 
   struct pipe_screen *screen = pipe->screen;
450
 
   struct xorg_shader shader;
451
 
 
452
 
   assert(screen->is_format_supported(screen, dst_surface->format,
453
 
                                      PIPE_TEXTURE_2D, 0,
454
 
                                      PIPE_BIND_RENDER_TARGET));
455
 
   (void) screen;
456
 
 
457
 
 
458
 
   /* set misc state we care about */
459
 
   {
460
 
      struct pipe_blend_state blend;
461
 
      memset(&blend, 0, sizeof(blend));
462
 
      blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
463
 
      blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
464
 
      blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
465
 
      blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
466
 
      blend.rt[0].colormask = PIPE_MASK_RGBA;
467
 
      cso_set_blend(r->cso, &blend);
468
 
   }
469
 
 
470
 
   /* sampler */
471
 
   {
472
 
      struct pipe_sampler_state sampler;
473
 
      memset(&sampler, 0, sizeof(sampler));
474
 
      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
475
 
      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
476
 
      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
477
 
      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
478
 
      sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
479
 
      sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
480
 
      sampler.normalized_coords = 1;
481
 
      cso_single_sampler(r->cso, 0, &sampler);
482
 
      cso_single_sampler_done(r->cso);
483
 
   }
484
 
 
485
 
   renderer_bind_destination(r, dst_surface, 
486
 
                             dst_surface->width,
487
 
                             dst_surface->height);
488
 
 
489
 
   /* texture/sampler view */
490
 
   {
491
 
      struct pipe_sampler_view templ;
492
 
      struct pipe_sampler_view *src_view;
493
 
      u_sampler_view_default_template(&templ,
494
 
                                      src_texture,
495
 
                                      src_texture->format);
496
 
      src_view = pipe->create_sampler_view(pipe, src_texture, &templ);
497
 
      cso_set_fragment_sampler_views(r->cso, 1, &src_view);
498
 
      pipe_sampler_view_reference(&src_view, NULL);
499
 
   }
500
 
 
501
 
   /* shaders */
502
 
   shader = xorg_shaders_get(r->shaders,
503
 
                             VS_COMPOSITE,
504
 
                             FS_COMPOSITE);
505
 
   cso_set_vertex_shader_handle(r->cso, shader.vs);
506
 
   cso_set_fragment_shader_handle(r->cso, shader.fs);
507
 
 
508
 
   r->buffer_size = 0;
509
 
   r->attrs_per_vertex = 2;
510
 
}
511
 
 
512
 
struct pipe_resource *
513
 
renderer_clone_texture(struct xorg_renderer *r,
514
 
                       struct pipe_resource *src)
515
 
{
516
 
   enum pipe_format format;
517
 
   struct pipe_context *pipe = r->pipe;
518
 
   struct pipe_screen *screen = pipe->screen;
519
 
   struct pipe_resource *pt;
520
 
   struct pipe_resource templ;
521
 
 
522
 
   /* the coming in texture should already have that invariance */
523
 
   debug_assert(screen->is_format_supported(screen, src->format,
524
 
                                            PIPE_TEXTURE_2D, 0,
525
 
                                            PIPE_BIND_SAMPLER_VIEW));
526
 
 
527
 
   format = src->format;
528
 
 
529
 
   memset(&templ, 0, sizeof(templ));
530
 
   templ.target = PIPE_TEXTURE_2D;
531
 
   templ.format = format;
532
 
   templ.last_level = 0;
533
 
   templ.width0 = src->width0;
534
 
   templ.height0 = src->height0;
535
 
   templ.depth0 = 1;
536
 
   templ.array_size = 1;
537
 
   templ.bind = PIPE_BIND_SAMPLER_VIEW;
538
 
 
539
 
   pt = screen->resource_create(screen, &templ);
540
 
 
541
 
   debug_assert(!pt || pipe_is_referenced(&pt->reference));
542
 
 
543
 
   if (!pt)
544
 
      return NULL;
545
 
 
546
 
   {
547
 
      /* copy source framebuffer surface into texture */
548
 
      struct pipe_box src_box;
549
 
      u_box_origin_2d(src->width0, src->height0, &src_box);
550
 
 
551
 
      pipe->resource_copy_region(pipe,
552
 
                                 pt, /* dest */
553
 
                                 0, /* dest_level */
554
 
                                 0, 0, 0, /* destx/y/z */
555
 
                                 src,
556
 
                                 0, &src_box);
557
 
   }
558
 
 
559
 
   return pt;
560
 
}
561
 
 
562
 
 
563
 
void renderer_copy_pixmap(struct xorg_renderer *r,
564
 
                          int dx, int dy,
565
 
                          int sx, int sy,
566
 
                          int width, int height,
567
 
                          float src_width,
568
 
                          float src_height)
569
 
{
570
 
   float s0, t0, s1, t1;
571
 
   float x0, y0, x1, y1;
572
 
 
573
 
 
574
 
   /* XXX: could put the texcoord scaling calculation into the vertex
575
 
    * shader.
576
 
    */
577
 
   s0 = sx            / src_width;
578
 
   s1 = (sx + width)  / src_width;
579
 
   t0 = sy            / src_height;
580
 
   t1 = (sy + height) / src_height;
581
 
 
582
 
   x0 = dx;
583
 
   x1 = dx + width;
584
 
   y0 = dy;
585
 
   y1 = dy + height;
586
 
 
587
 
   /* draw quad */
588
 
   renderer_draw_conditional(r, 4*8);
589
 
   add_vertex_1tex(r, x0, y0, s0, t0);
590
 
   add_vertex_1tex(r, x1, y0, s1, t0);
591
 
   add_vertex_1tex(r, x1, y1, s1, t1);
592
 
   add_vertex_1tex(r, x0, y1, s0, t1);
593
 
}
594
 
 
 
433
   pipe_set_constant_buffer(r->pipe, shader_type, 0, *cbuf);
 
434
}
595
435
 
596
436
 
597
437
 
600
440
                       int dst_x, int dst_y, int dst_w, int dst_h,
601
441
                       struct pipe_resource **textures)
602
442
{
603
 
   struct pipe_context *pipe = r->pipe;
604
 
   struct pipe_resource *buf = 0;
605
 
 
606
 
   buf = setup_vertex_data_yuv(r,
607
 
                               src_x, src_y, src_w, src_h,
608
 
                               dst_x, dst_y, dst_w, dst_h,
609
 
                               textures);
610
 
 
611
 
   if (buf) {
612
 
      const int num_attribs = 2; /*pos + tex coord*/
613
 
 
614
 
      cso_set_vertex_elements(r->cso, num_attribs, r->velems);
615
 
 
616
 
      util_draw_vertex_buffer(pipe, r->cso, buf, 0,
617
 
                              PIPE_PRIM_QUADS,
618
 
                              4,  /* verts */
619
 
                              num_attribs); /* attribs/vert */
620
 
 
621
 
      pipe_resource_reference(&buf, NULL);
622
 
   }
 
443
   const int num_attribs = 2; /*pos + tex coord*/
 
444
 
 
445
   setup_vertex_data_yuv(r,
 
446
                         src_x, src_y, src_w, src_h,
 
447
                         dst_x, dst_y, dst_w, dst_h,
 
448
                         textures);
 
449
 
 
450
   cso_set_vertex_elements(r->cso, num_attribs, r->velems);
 
451
 
 
452
   util_draw_user_vertex_buffer(r->cso, r->buffer,
 
453
                                PIPE_PRIM_QUADS,
 
454
                                4,  /* verts */
 
455
                                num_attribs); /* attribs/vert */
 
456
 
 
457
   r->buffer_size = 0;
623
458
}
624
459
 
625
460
void renderer_begin_solid(struct xorg_renderer *r)