← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/drivers/nv30/nv30_transfer.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/nv30/nv30_transfer.c
1
 
#include "pipe/p_state.h"
2
 
#include "pipe/p_defines.h"
3
 
#include "util/u_inlines.h"
4
 
#include "util/u_format.h"
5
 
#include "util/u_memory.h"
6
 
#include "util/u_math.h"
7
 
#include "nouveau/nouveau_winsys.h"
8
 
#include "nv30_context.h"
9
 
#include "nv30_screen.h"
10
 
#include "nv30_state.h"
11
 
 
12
 
struct nv30_transfer {
13
 
        struct pipe_transfer base;
14
 
        struct pipe_surface *surface;
15
 
        boolean direct;
16
 
};
17
 
 
18
 
static void
19
 
nv30_compatible_transfer_tex(struct pipe_texture *pt, unsigned width, unsigned height,
20
 
                             struct pipe_texture *template)
21
 
{
22
 
        memset(template, 0, sizeof(struct pipe_texture));
23
 
        template->target = pt->target;
24
 
        template->format = pt->format;
25
 
        template->width0 = width;
26
 
        template->height0 = height;
27
 
        template->depth0 = 1;
28
 
        template->last_level = 0;
29
 
        template->nr_samples = pt->nr_samples;
30
 
 
31
 
        template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
32
 
                              NOUVEAU_TEXTURE_USAGE_LINEAR;
33
 
}
34
 
 
35
 
static struct pipe_transfer *
36
 
nv30_transfer_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
37
 
                  unsigned face, unsigned level, unsigned zslice,
38
 
                  enum pipe_transfer_usage usage,
39
 
                  unsigned x, unsigned y, unsigned w, unsigned h)
40
 
{
41
 
        struct nv30_miptree *mt = (struct nv30_miptree *)pt;
42
 
        struct nv30_transfer *tx;
43
 
        struct pipe_texture tx_tex_template, *tx_tex;
44
 
 
45
 
        tx = CALLOC_STRUCT(nv30_transfer);
46
 
        if (!tx)
47
 
                return NULL;
48
 
 
49
 
        pipe_texture_reference(&tx->base.texture, pt);
50
 
        tx->base.x = x;
51
 
        tx->base.y = y;
52
 
        tx->base.width = w;
53
 
        tx->base.height = h;
54
 
        tx->base.stride = mt->level[level].pitch;
55
 
        tx->base.usage = usage;
56
 
        tx->base.face = face;
57
 
        tx->base.level = level;
58
 
        tx->base.zslice = zslice;
59
 
 
60
 
        /* Direct access to texture */
61
 
        if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC ||
62
 
             debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/)) &&
63
 
            pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
64
 
        {
65
 
                tx->direct = true;
66
 
                tx->surface = pscreen->get_tex_surface(pscreen, pt,
67
 
                                                       face, level, zslice,
68
 
                                                       pipe_transfer_buffer_flags(&tx->base));
69
 
                return &tx->base;
70
 
        }
71
 
 
72
 
        tx->direct = false;
73
 
 
74
 
        nv30_compatible_transfer_tex(pt, w, h, &tx_tex_template);
75
 
 
76
 
        tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
77
 
        if (!tx_tex)
78
 
        {
79
 
                FREE(tx);
80
 
                return NULL;
81
 
        }
82
 
 
83
 
        tx->base.stride = ((struct nv30_miptree*)tx_tex)->level[0].pitch;
84
 
 
85
 
        tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
86
 
                                               0, 0, 0,
87
 
                                               pipe_transfer_buffer_flags(&tx->base));
88
 
 
89
 
        pipe_texture_reference(&tx_tex, NULL);
90
 
 
91
 
        if (!tx->surface)
92
 
        {
93
 
                pipe_surface_reference(&tx->surface, NULL);
94
 
                FREE(tx);
95
 
                return NULL;
96
 
        }
97
 
 
98
 
        if (usage & PIPE_TRANSFER_READ) {
99
 
                struct nv30_screen *nvscreen = nv30_screen(pscreen);
100
 
                struct pipe_surface *src;
101
 
 
102
 
                src = pscreen->get_tex_surface(pscreen, pt,
103
 
                                               face, level, zslice,
104
 
                                               PIPE_BUFFER_USAGE_GPU_READ);
105
 
 
106
 
                /* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
107
 
                /* TODO: Check if SIFM can un-swizzle */
108
 
                nvscreen->eng2d->copy(nvscreen->eng2d,
109
 
                                      tx->surface, 0, 0,
110
 
                                      src, x, y,
111
 
                                      w, h);
112
 
 
113
 
                pipe_surface_reference(&src, NULL);
114
 
        }
115
 
 
116
 
        return &tx->base;
117
 
}
118
 
 
119
 
static void
120
 
nv30_transfer_del(struct pipe_transfer *ptx)
121
 
{
122
 
        struct nv30_transfer *tx = (struct nv30_transfer *)ptx;
123
 
 
124
 
        if (!tx->direct && (ptx->usage & PIPE_TRANSFER_WRITE)) {
125
 
                struct pipe_screen *pscreen = ptx->texture->screen;
126
 
                struct nv30_screen *nvscreen = nv30_screen(pscreen);
127
 
                struct pipe_surface *dst;
128
 
 
129
 
                dst = pscreen->get_tex_surface(pscreen, ptx->texture,
130
 
                                               ptx->face, ptx->level, ptx->zslice,
131
 
                                               PIPE_BUFFER_USAGE_GPU_WRITE | NOUVEAU_BUFFER_USAGE_NO_RENDER);
132
 
 
133
 
                /* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
134
 
                nvscreen->eng2d->copy(nvscreen->eng2d,
135
 
                                      dst, tx->base.x, tx->base.y,
136
 
                                      tx->surface, 0, 0,
137
 
                                      tx->base.width, tx->base.height);
138
 
 
139
 
                pipe_surface_reference(&dst, NULL);
140
 
        }
141
 
 
142
 
        pipe_surface_reference(&tx->surface, NULL);
143
 
        pipe_texture_reference(&ptx->texture, NULL);
144
 
        FREE(ptx);
145
 
}
146
 
 
147
 
static void *
148
 
nv30_transfer_map(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
149
 
{
150
 
        struct nv30_transfer *tx = (struct nv30_transfer *)ptx;
151
 
        struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
152
 
        struct nv30_miptree *mt = (struct nv30_miptree *)tx->surface->texture;
153
 
        void *map = pipe_buffer_map(pscreen, mt->buffer,
154
 
                                    pipe_transfer_buffer_flags(ptx));
155
 
 
156
 
        if(!tx->direct)
157
 
                return map + ns->base.offset;
158
 
        else
159
 
                return map + ns->base.offset + ptx->y * ns->pitch + ptx->x * util_format_get_blocksize(ptx->texture->format);
160
 
}
161
 
 
162
 
static void
163
 
nv30_transfer_unmap(struct pipe_screen *pscreen, struct pipe_transfer *ptx)
164
 
{
165
 
        struct nv30_transfer *tx = (struct nv30_transfer *)ptx;
166
 
        struct nv30_miptree *mt = (struct nv30_miptree *)tx->surface->texture;
167
 
 
168
 
        pipe_buffer_unmap(pscreen, mt->buffer);
169
 
}
170
 
 
171
 
void
172
 
nv30_screen_init_transfer_functions(struct pipe_screen *pscreen)
173
 
{
174
 
        pscreen->get_tex_transfer = nv30_transfer_new;
175
 
        pscreen->tex_transfer_destroy = nv30_transfer_del;
176
 
        pscreen->transfer_map = nv30_transfer_map;
177
 
        pscreen->transfer_unmap = nv30_transfer_unmap;
178
 
}