vao_freelist_max_length(vao_freelist_max_length),
texture_freelist_bytes(0)
{
- pthread_mutex_init(&lock, NULL);
+ pthread_mutex_init(&lock, nullptr);
}
ResourcePool::~ResourcePool()
void *context = get_gl_context_identifier();
cleanup_unlinked_fbos(context);
- for (map<void *, std::list<FBOFormatIterator> >::iterator context_it = fbo_freelist.begin();
+ for (map<void *, std::list<FBOFormatIterator>>::iterator context_it = fbo_freelist.begin();
context_it != fbo_freelist.end();
++context_it) {
if (context_it->first != context) {
}
assert(found_program);
- map<GLuint, stack<GLuint> >::iterator instance_list_it = program_instances.find(glsl_program_num);
+ map<GLuint, stack<GLuint>>::iterator instance_list_it = program_instances.find(glsl_program_num);
assert(instance_list_it != program_instances.end());
while (!instance_list_it->second.empty()) {
const pair<string, string> key(vertex_shader, fragment_shader_processed);
if (programs.count(key)) {
- // Already in the cache. Increment the refcount, or take it off the freelist
- // if it's zero.
+ // Already in the cache.
glsl_program_num = programs[key];
- map<GLuint, int>::iterator refcount_it = program_refcount.find(glsl_program_num);
- if (refcount_it != program_refcount.end()) {
- ++refcount_it->second;
- } else {
- list<GLuint>::iterator freelist_it =
- find(program_freelist.begin(), program_freelist.end(), glsl_program_num);
- assert(freelist_it != program_freelist.end());
- program_freelist.erase(freelist_it);
- program_refcount.insert(make_pair(glsl_program_num, 1));
- }
+ increment_program_refcount(glsl_program_num);
} else {
// Not in the cache. Compile the shaders.
GLuint vs_obj = compile_shader(vertex_shader, GL_VERTEX_SHADER);
check_error();
glsl_program_num = link_program(vs_obj, fs_obj, fragment_shader_outputs);
- if (movit_debug_level == MOVIT_DEBUG_ON) {
- // Output shader to a temporary file, for easier debugging.
- static int compiled_shader_num = 0;
- char filename[256];
- sprintf(filename, "chain-%03d.frag", compiled_shader_num++);
- FILE *fp = fopen(filename, "w");
- if (fp == NULL) {
- perror(filename);
- exit(1);
- }
- fprintf(fp, "%s\n", fragment_shader_processed.c_str());
- fclose(fp);
- }
+ output_debug_shader(fragment_shader_processed, "frag");
programs.insert(make_pair(key, glsl_program_num));
- program_refcount.insert(make_pair(glsl_program_num, 1));
+ add_master_program(glsl_program_num);
+
ShaderSpec spec;
spec.vs_obj = vs_obj;
spec.fs_obj = fs_obj;
spec.fragment_shader_outputs = fragment_shader_outputs;
program_shaders.insert(make_pair(glsl_program_num, spec));
- stack<GLuint> instances;
- instances.push(glsl_program_num);
- program_instances.insert(make_pair(glsl_program_num, instances));
- program_masters.insert(make_pair(glsl_program_num, glsl_program_num));
}
pthread_mutex_unlock(&lock);
return glsl_program_num;
glGetProgramiv(glsl_program_num, GL_LINK_STATUS, &success);
if (success == GL_FALSE) {
GLchar error_log[1024] = {0};
- glGetProgramInfoLog(glsl_program_num, 1024, NULL, error_log);
+ glGetProgramInfoLog(glsl_program_num, 1024, nullptr, error_log);
fprintf(stderr, "Error linking program: %s\n", error_log);
exit(1);
}
pthread_mutex_unlock(&lock);
}
+GLuint ResourcePool::compile_glsl_compute_program(const string& compute_shader)
+{
+ GLuint glsl_program_num;
+ pthread_mutex_lock(&lock);
+
+ const string &key = compute_shader;
+ if (compute_programs.count(key)) {
+ // Already in the cache.
+ glsl_program_num = compute_programs[key];
+ increment_program_refcount(glsl_program_num);
+ } else {
+ // Not in the cache. Compile the shader.
+ GLuint cs_obj = compile_shader(compute_shader, GL_COMPUTE_SHADER);
+ check_error();
+ glsl_program_num = link_compute_program(cs_obj);
+
+ output_debug_shader(compute_shader, "compute");
+
+ compute_programs.insert(make_pair(key, glsl_program_num));
+ add_master_program(glsl_program_num);
+
+ ComputeShaderSpec spec;
+ spec.cs_obj = cs_obj;
+ compute_program_shaders.insert(make_pair(glsl_program_num, spec));
+ }
+ pthread_mutex_unlock(&lock);
+ return glsl_program_num;
+}
+
+GLuint ResourcePool::link_compute_program(GLuint cs_obj)
+{
+ GLuint glsl_program_num = glCreateProgram();
+ check_error();
+ glAttachShader(glsl_program_num, cs_obj);
+ check_error();
+ glLinkProgram(glsl_program_num);
+ check_error();
+
+ GLint success;
+ glGetProgramiv(glsl_program_num, GL_LINK_STATUS, &success);
+ if (success == GL_FALSE) {
+ GLchar error_log[1024] = {0};
+ glGetProgramInfoLog(glsl_program_num, 1024, nullptr, error_log);
+ fprintf(stderr, "Error linking program: %s\n", error_log);
+ exit(1);
+ }
+
+ return glsl_program_num;
+}
+
GLuint ResourcePool::use_glsl_program(GLuint glsl_program_num)
{
pthread_mutex_lock(&lock);
// will later put it onto the list.)
map<GLuint, ShaderSpec>::iterator shader_it =
program_shaders.find(glsl_program_num);
- assert(shader_it != program_shaders.end());
-
- instance_program_num = link_program(
- shader_it->second.vs_obj,
- shader_it->second.fs_obj,
- shader_it->second.fragment_shader_outputs);
+ if (shader_it == program_shaders.end()) {
+ // Should be a compute shader.
+ map<GLuint, ComputeShaderSpec>::iterator compute_shader_it =
+ compute_program_shaders.find(glsl_program_num);
+ instance_program_num = link_compute_program(
+ compute_shader_it->second.cs_obj);
+ } else {
+ // A regular fragment shader.
+ instance_program_num = link_program(
+ shader_it->second.vs_obj,
+ shader_it->second.fs_obj,
+ shader_it->second.fragment_shader_outputs);
+ }
program_masters.insert(make_pair(instance_program_num, glsl_program_num));
}
pthread_mutex_unlock(&lock);
}
// Find any reasonable format given the internal format; OpenGL validates it
- // even though we give NULL as pointer.
+ // even though we give nullptr as pointer.
GLenum format;
switch (internal_format) {
case GL_RGBA32F_ARB:
check_error();
glBindTexture(GL_TEXTURE_2D, texture_num);
check_error();
- glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, type, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, type, nullptr);
check_error();
glBindTexture(GL_TEXTURE_2D, 0);
check_error();
}
}
+void ResourcePool::increment_program_refcount(GLuint program_num)
+{
+ map<GLuint, int>::iterator refcount_it = program_refcount.find(program_num);
+ if (refcount_it != program_refcount.end()) {
+ ++refcount_it->second;
+ } else {
+ list<GLuint>::iterator freelist_it =
+ find(program_freelist.begin(), program_freelist.end(), program_num);
+ assert(freelist_it != program_freelist.end());
+ program_freelist.erase(freelist_it);
+ program_refcount.insert(make_pair(program_num, 1));
+ }
+}
+
+void ResourcePool::output_debug_shader(const string &shader_src, const string &suffix)
+{
+ if (movit_debug_level == MOVIT_DEBUG_ON) {
+ // Output shader to a temporary file, for easier debugging.
+ static int compiled_shader_num = 0;
+ char filename[256];
+ sprintf(filename, "chain-%03d.%s", compiled_shader_num++, suffix.c_str());
+ FILE *fp = fopen(filename, "w");
+ if (fp == nullptr) {
+ perror(filename);
+ exit(1);
+ }
+ fprintf(fp, "%s\n", shader_src.c_str());
+ fclose(fp);
+ }
+}
+
+void ResourcePool::add_master_program(GLuint program_num)
+{
+ program_refcount.insert(make_pair(program_num, 1));
+ stack<GLuint> instances;
+ instances.push(program_num);
+ program_instances.insert(make_pair(program_num, instances));
+ program_masters.insert(make_pair(program_num, program_num));
+}
+
size_t ResourcePool::estimate_texture_size(const Texture2D &texture_format)
{
size_t bytes_per_pixel;
projects / movit / blobdiff