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"
32 #include "pipe/p_screen.h"
33 #include "util/u_inlines.h"
34 #include "util/u_math.h"
35 #include "util/u_debug.h"
36 #include "util/u_memory.h"
37 #include "cso_cache/cso_context.h"
39 /** Initialize the post-processing queue. */
41 pp_init(struct pipe_context
*pipe
, const unsigned int *enabled
,
42 struct cso_context
*cso
)
44 unsigned int num_filters
= 0;
45 unsigned int curpos
= 0, i
, tmp_req
= 0;
46 struct pp_queue_t
*ppq
;
48 pp_debug("Initializing the post-processing queue.\n");
50 /* How many filters were requested? */
51 for (i
= 0; i
< PP_FILTERS
; i
++) {
58 ppq
= CALLOC(1, sizeof(struct pp_queue_t
));
61 pp_debug("Unable to allocate memory for ppq.\n");
65 ppq
->pp_queue
= CALLOC(num_filters
, sizeof(pp_func
));
66 if (ppq
->pp_queue
== NULL
) {
67 pp_debug("Unable to allocate memory for pp_queue.\n");
71 ppq
->shaders
= CALLOC(num_filters
, sizeof(void *));
72 ppq
->filters
= CALLOC(num_filters
, sizeof(unsigned int));
74 if ((ppq
->shaders
== NULL
) ||
75 (ppq
->filters
== NULL
)) {
76 pp_debug("Unable to allocate memory for shaders and filter arrays.\n");
80 ppq
->p
= pp_init_prog(ppq
, pipe
, cso
);
82 pp_debug("pp_init_prog returned NULL.\n");
86 /* Add the enabled filters to the queue, in order */
88 for (i
= 0; i
< PP_FILTERS
; i
++) {
90 ppq
->pp_queue
[curpos
] = pp_filters
[i
].main
;
91 tmp_req
= MAX2(tmp_req
, pp_filters
[i
].inner_tmps
);
92 ppq
->filters
[curpos
] = i
;
94 if (pp_filters
[i
].shaders
) {
95 ppq
->shaders
[curpos
] =
96 CALLOC(pp_filters
[i
].shaders
+ 1, sizeof(void *));
97 if (!ppq
->shaders
[curpos
]) {
98 pp_debug("Unable to allocate memory for shader list.\n");
103 /* Call the initialization function for the filter. */
104 if (!pp_filters
[i
].init(ppq
, curpos
, enabled
[i
])) {
105 pp_debug("Initialization for filter %u failed.\n", i
);
113 ppq
->n_filters
= curpos
;
114 ppq
->n_tmp
= (curpos
> 2 ? 2 : 1);
115 ppq
->n_inner_tmp
= tmp_req
;
117 ppq
->fbos_init
= false;
119 for (i
= 0; i
< curpos
; i
++)
120 ppq
->shaders
[i
][0] = ppq
->p
->passvs
;
122 pp_debug("Queue successfully allocated. %u filter(s).\n", curpos
);
129 /* Assign curpos, since we only need to destroy initialized filters. */
130 ppq
->n_filters
= curpos
;
132 /* Call the common free function which must handle partial initialization. */
139 /** Free any allocated FBOs (temp buffers). Called after resizing for example. */
141 pp_free_fbos(struct pp_queue_t
*ppq
)
149 for (i
= 0; i
< ppq
->n_tmp
; i
++) {
150 pipe_surface_reference(&ppq
->tmps
[i
], NULL
);
151 pipe_resource_reference(&ppq
->tmp
[i
], NULL
);
153 for (i
= 0; i
< ppq
->n_inner_tmp
; i
++) {
154 pipe_surface_reference(&ppq
->inner_tmps
[i
], NULL
);
155 pipe_resource_reference(&ppq
->inner_tmp
[i
], NULL
);
157 pipe_surface_reference(&ppq
->stencils
, NULL
);
158 pipe_resource_reference(&ppq
->stencil
, NULL
);
160 ppq
->fbos_init
= false;
164 * Free the pp queue. Called on context termination and failure in
168 pp_free(struct pp_queue_t
*ppq
)
178 if (ppq
->p
->pipe
&& ppq
->filters
&& ppq
->shaders
) {
179 for (i
= 0; i
< ppq
->n_filters
; i
++) {
180 unsigned int filter
= ppq
->filters
[i
];
182 if (ppq
->shaders
[i
] == NULL
) {
187 * Common shader destruction code for all postprocessing
190 for (j
= 0; j
< pp_filters
[filter
].shaders
; j
++) {
191 if (ppq
->shaders
[i
][j
] == NULL
) {
192 /* We reached the end of initialized shaders. */
196 if (ppq
->shaders
[i
][j
] == ppq
->p
->passvs
) {
202 assert(ppq
->p
->pipe
);
204 if (j
>= pp_filters
[filter
].verts
) {
205 assert(ppq
->p
->pipe
->delete_fs_state
);
206 ppq
->p
->pipe
->delete_fs_state(ppq
->p
->pipe
,
208 ppq
->shaders
[i
][j
] = NULL
;
210 assert(ppq
->p
->pipe
->delete_vs_state
);
211 ppq
->p
->pipe
->delete_vs_state(ppq
->p
->pipe
,
213 ppq
->shaders
[i
][j
] = NULL
;
217 /* Finally call each filter type's free functionality. */
218 pp_filters
[filter
].free(ppq
, i
);
226 * Handle partial initialization for common resource destruction
227 * in the create path.
235 pp_debug("Queue taken down.\n");
238 /** Internal debug function. Should be available to final users. */
240 pp_debug(const char *fmt
, ...)
244 if (!debug_get_bool_option("PP_DEBUG", FALSE
))
248 _debug_vprintf(fmt
, ap
);
252 /** Allocate the temp FBOs. Called on makecurrent and resize. */
254 pp_init_fbos(struct pp_queue_t
*ppq
, unsigned int w
,
258 struct pp_program
*p
= ppq
->p
; /* The lazy will inherit the earth */
261 struct pipe_resource tmp_res
;
266 pp_debug("Initializing FBOs, size %ux%u\n", w
, h
);
267 pp_debug("Requesting %u temps and %u inner temps\n", ppq
->n_tmp
,
270 memset(&tmp_res
, 0, sizeof(tmp_res
));
271 tmp_res
.target
= PIPE_TEXTURE_2D
;
272 tmp_res
.format
= p
->surf
.format
= PIPE_FORMAT_B8G8R8A8_UNORM
;
276 tmp_res
.array_size
= 1;
277 tmp_res
.last_level
= 0;
278 tmp_res
.bind
= PIPE_BIND_RENDER_TARGET
;
280 if (!p
->screen
->is_format_supported(p
->screen
, tmp_res
.format
,
281 tmp_res
.target
, 1, tmp_res
.bind
))
282 pp_debug("Temp buffers' format fail\n");
284 for (i
= 0; i
< ppq
->n_tmp
; i
++) {
285 ppq
->tmp
[i
] = p
->screen
->resource_create(p
->screen
, &tmp_res
);
286 ppq
->tmps
[i
] = p
->pipe
->create_surface(p
->pipe
, ppq
->tmp
[i
], &p
->surf
);
288 if (!ppq
->tmp
[i
] || !ppq
->tmps
[i
])
292 for (i
= 0; i
< ppq
->n_inner_tmp
; i
++) {
293 ppq
->inner_tmp
[i
] = p
->screen
->resource_create(p
->screen
, &tmp_res
);
294 ppq
->inner_tmps
[i
] = p
->pipe
->create_surface(p
->pipe
,
298 if (!ppq
->inner_tmp
[i
] || !ppq
->inner_tmps
[i
])
302 tmp_res
.bind
= PIPE_BIND_DEPTH_STENCIL
;
304 tmp_res
.format
= p
->surf
.format
= PIPE_FORMAT_S8_UINT_Z24_UNORM
;
306 if (!p
->screen
->is_format_supported(p
->screen
, tmp_res
.format
,
307 tmp_res
.target
, 1, tmp_res
.bind
)) {
309 tmp_res
.format
= p
->surf
.format
= PIPE_FORMAT_Z24_UNORM_S8_UINT
;
311 if (!p
->screen
->is_format_supported(p
->screen
, tmp_res
.format
,
312 tmp_res
.target
, 1, tmp_res
.bind
))
313 pp_debug("Temp Sbuffer format fail\n");
316 ppq
->stencil
= p
->screen
->resource_create(p
->screen
, &tmp_res
);
317 ppq
->stencils
= p
->pipe
->create_surface(p
->pipe
, ppq
->stencil
, &p
->surf
);
318 if (!ppq
->stencil
|| !ppq
->stencils
)
321 p
->framebuffer
.width
= w
;
322 p
->framebuffer
.height
= h
;
324 p
->viewport
.scale
[0] = p
->viewport
.translate
[0] = (float) w
/ 2.0f
;
325 p
->viewport
.scale
[1] = p
->viewport
.translate
[1] = (float) h
/ 2.0f
;
326 p
->viewport
.scale
[3] = 1.0f
;
327 p
->viewport
.translate
[3] = 0.0f
;
329 ppq
->fbos_init
= true;
334 pp_debug("Failed to allocate temp buffers!\n");