1 /**************************************************************************
3 * Copyright 2011 Lauri Kasanen
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "pipe/p_compiler.h"
30 #include "postprocess/filters.h"
31 #include "postprocess/pp_private.h"
33 #include "pipe/p_screen.h"
34 #include "util/u_inlines.h"
35 #include "util/u_math.h"
36 #include "util/u_debug.h"
37 #include "util/u_memory.h"
38 #include "cso_cache/cso_context.h"
40 /** Initialize the post-processing queue. */
42 pp_init(struct pipe_context
*pipe
, const unsigned int *enabled
,
43 struct cso_context
*cso
)
45 unsigned int num_filters
= 0;
46 unsigned int curpos
= 0, i
, tmp_req
= 0;
47 struct pp_queue_t
*ppq
;
49 pp_debug("Initializing the post-processing queue.\n");
51 /* How many filters were requested? */
52 for (i
= 0; i
< PP_FILTERS
; i
++) {
59 ppq
= CALLOC(1, sizeof(struct pp_queue_t
));
62 pp_debug("Unable to allocate memory for ppq.\n");
66 ppq
->pp_queue
= CALLOC(num_filters
, sizeof(pp_func
));
67 if (ppq
->pp_queue
== NULL
) {
68 pp_debug("Unable to allocate memory for pp_queue.\n");
72 ppq
->shaders
= CALLOC(num_filters
, sizeof(void *));
73 ppq
->filters
= CALLOC(num_filters
, sizeof(unsigned int));
75 if ((ppq
->shaders
== NULL
) ||
76 (ppq
->filters
== NULL
)) {
77 pp_debug("Unable to allocate memory for shaders and filter arrays.\n");
81 ppq
->p
= pp_init_prog(ppq
, pipe
, cso
);
83 pp_debug("pp_init_prog returned NULL.\n");
87 /* Add the enabled filters to the queue, in order */
89 for (i
= 0; i
< PP_FILTERS
; i
++) {
91 ppq
->pp_queue
[curpos
] = pp_filters
[i
].main
;
92 tmp_req
= MAX2(tmp_req
, pp_filters
[i
].inner_tmps
);
93 ppq
->filters
[curpos
] = i
;
95 if (pp_filters
[i
].shaders
) {
96 ppq
->shaders
[curpos
] =
97 CALLOC(pp_filters
[i
].shaders
+ 1, sizeof(void *));
98 if (!ppq
->shaders
[curpos
]) {
99 pp_debug("Unable to allocate memory for shader list.\n");
104 /* Call the initialization function for the filter. */
105 if (!pp_filters
[i
].init(ppq
, curpos
, enabled
[i
])) {
106 pp_debug("Initialization for filter %u failed.\n", i
);
114 ppq
->n_filters
= curpos
;
115 ppq
->n_tmp
= (curpos
> 2 ? 2 : 1);
116 ppq
->n_inner_tmp
= tmp_req
;
118 ppq
->fbos_init
= false;
120 for (i
= 0; i
< curpos
; i
++)
121 ppq
->shaders
[i
][0] = ppq
->p
->passvs
;
123 pp_debug("Queue successfully allocated. %u filter(s).\n", curpos
);
130 /* Assign curpos, since we only need to destroy initialized filters. */
131 ppq
->n_filters
= curpos
;
133 /* Call the common free function which must handle partial initialization. */
140 /** Free any allocated FBOs (temp buffers). Called after resizing for example. */
142 pp_free_fbos(struct pp_queue_t
*ppq
)
150 for (i
= 0; i
< ppq
->n_tmp
; i
++) {
151 pipe_surface_reference(&ppq
->tmps
[i
], NULL
);
152 pipe_resource_reference(&ppq
->tmp
[i
], NULL
);
154 for (i
= 0; i
< ppq
->n_inner_tmp
; i
++) {
155 pipe_surface_reference(&ppq
->inner_tmps
[i
], NULL
);
156 pipe_resource_reference(&ppq
->inner_tmp
[i
], NULL
);
158 pipe_surface_reference(&ppq
->stencils
, NULL
);
159 pipe_resource_reference(&ppq
->stencil
, NULL
);
161 ppq
->fbos_init
= false;
165 * Free the pp queue. Called on context termination and failure in
169 pp_free(struct pp_queue_t
*ppq
)
179 if (ppq
->p
->pipe
&& ppq
->filters
&& ppq
->shaders
) {
180 for (i
= 0; i
< ppq
->n_filters
; i
++) {
181 unsigned int filter
= ppq
->filters
[i
];
183 if (ppq
->shaders
[i
] == NULL
) {
188 * Common shader destruction code for all postprocessing
191 for (j
= 0; j
< pp_filters
[filter
].shaders
; j
++) {
192 if (ppq
->shaders
[i
][j
] == NULL
) {
193 /* We reached the end of initialized shaders. */
197 if (ppq
->shaders
[i
][j
] == ppq
->p
->passvs
) {
203 assert(ppq
->p
->pipe
);
205 if (j
>= pp_filters
[filter
].verts
) {
206 assert(ppq
->p
->pipe
->delete_fs_state
);
207 ppq
->p
->pipe
->delete_fs_state(ppq
->p
->pipe
,
209 ppq
->shaders
[i
][j
] = NULL
;
211 assert(ppq
->p
->pipe
->delete_vs_state
);
212 ppq
->p
->pipe
->delete_vs_state(ppq
->p
->pipe
,
214 ppq
->shaders
[i
][j
] = NULL
;
218 /* Finally call each filter type's free functionality. */
219 pp_filters
[filter
].free(ppq
, i
);
227 * Handle partial initialization for common resource destruction
228 * in the create path.
236 pp_debug("Queue taken down.\n");
239 /** Internal debug function. Should be available to final users. */
241 pp_debug(const char *fmt
, ...)
245 if (!debug_get_bool_option("PP_DEBUG", FALSE
))
249 _debug_vprintf(fmt
, ap
);
253 /** Allocate the temp FBOs. Called on makecurrent and resize. */
255 pp_init_fbos(struct pp_queue_t
*ppq
, unsigned int w
,
259 struct pp_program
*p
= ppq
->p
; /* The lazy will inherit the earth */
262 struct pipe_resource tmp_res
;
267 pp_debug("Initializing FBOs, size %ux%u\n", w
, h
);
268 pp_debug("Requesting %u temps and %u inner temps\n", ppq
->n_tmp
,
271 memset(&tmp_res
, 0, sizeof(tmp_res
));
272 tmp_res
.target
= PIPE_TEXTURE_2D
;
273 tmp_res
.format
= p
->surf
.format
= PIPE_FORMAT_B8G8R8A8_UNORM
;
277 tmp_res
.array_size
= 1;
278 tmp_res
.last_level
= 0;
279 tmp_res
.bind
= PIPE_BIND_RENDER_TARGET
;
281 if (!p
->screen
->is_format_supported(p
->screen
, tmp_res
.format
,
282 tmp_res
.target
, 1, tmp_res
.bind
))
283 pp_debug("Temp buffers' format fail\n");
285 for (i
= 0; i
< ppq
->n_tmp
; i
++) {
286 ppq
->tmp
[i
] = p
->screen
->resource_create(p
->screen
, &tmp_res
);
287 ppq
->tmps
[i
] = p
->pipe
->create_surface(p
->pipe
, ppq
->tmp
[i
], &p
->surf
);
289 if (!ppq
->tmp
[i
] || !ppq
->tmps
[i
])
293 for (i
= 0; i
< ppq
->n_inner_tmp
; i
++) {
294 ppq
->inner_tmp
[i
] = p
->screen
->resource_create(p
->screen
, &tmp_res
);
295 ppq
->inner_tmps
[i
] = p
->pipe
->create_surface(p
->pipe
,
299 if (!ppq
->inner_tmp
[i
] || !ppq
->inner_tmps
[i
])
303 tmp_res
.bind
= PIPE_BIND_DEPTH_STENCIL
;
305 tmp_res
.format
= p
->surf
.format
= PIPE_FORMAT_S8_UINT_Z24_UNORM
;
307 if (!p
->screen
->is_format_supported(p
->screen
, tmp_res
.format
,
308 tmp_res
.target
, 1, tmp_res
.bind
)) {
310 tmp_res
.format
= p
->surf
.format
= PIPE_FORMAT_Z24_UNORM_S8_UINT
;
312 if (!p
->screen
->is_format_supported(p
->screen
, tmp_res
.format
,
313 tmp_res
.target
, 1, tmp_res
.bind
))
314 pp_debug("Temp Sbuffer format fail\n");
317 ppq
->stencil
= p
->screen
->resource_create(p
->screen
, &tmp_res
);
318 ppq
->stencils
= p
->pipe
->create_surface(p
->pipe
, ppq
->stencil
, &p
->surf
);
319 if (!ppq
->stencil
|| !ppq
->stencils
)
322 p
->framebuffer
.width
= w
;
323 p
->framebuffer
.height
= h
;
325 p
->viewport
.scale
[0] = p
->viewport
.translate
[0] = (float) w
/ 2.0f
;
326 p
->viewport
.scale
[1] = p
->viewport
.translate
[1] = (float) h
/ 2.0f
;
327 p
->viewport
.scale
[3] = 1.0f
;
328 p
->viewport
.translate
[3] = 0.0f
;
330 ppq
->fbos_init
= true;
335 pp_debug("Failed to allocate temp buffers!\n");