android/android-emugl/host/libs/libGLES12Translator/gles/program_data.cpp - qemu-android - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "gles/program_data.h"

 #include <stdio.h>
 #include <GLES/glext.h>

 #include "common/alog.h"
 #include "gles/debug.h"
 #include "gles/gles_context.h"
 #include "gles/macros.h"
 #include "gles/shader_data.h"

 using android::base::AutoLock;

 static GlesContext* GetRequiredContext() {
   GlesContext* ctx = GetCurrentGlesContext();
   LOG_ALWAYS_FATAL_IF(!ctx);
   return ctx;
 }

 ProgramData::ProgramData(ObjectLocalName name)
   : ObjectData(PROGRAM, name), current_program_(new ProgramVariant()),
     uniform_location_gen_(0), has_link_failure_(false),
     has_warned_about_sampler_use_(false), use_count_(0),
     uniform_revision_gen_(0), validation_status_(GL_FALSE) {
 }

 ProgramData::~ProgramData() {
   if (use_count_) {
     ALOGE("ProgramData destroyed while use count is %d", use_count_);
   }
   ClearUniformCacheLocked();
 }

 void ProgramData::ModifyProgramLocked() {
   if (linked_programs_.empty() ||
       current_program_ != linked_programs_[0].GetProgram()) {
     return;  // Already modifying a new program variant.
   }
   // The program has been linked and may be in use. Create a new one.
   current_program_ = ProgramVariantPtr(
       linked_programs_[0].GetProgram()->Clone());
   // TODO(crbug.com/441928): Support a case where a linked program gets
   // modified, its compiled shader is re-attached, and then shader source
   // is updated.
 }

 void ProgramData::AttachShader(const ShaderDataPtr& shader) {
   AutoLock lock(lock_);
   // Check type correctness and that there is no existing shader with that type.
   ObjectType type = shader->GetDataType();
   LOG_ALWAYS_FATAL_IF(type != VERTEX_SHADER && type != FRAGMENT_SHADER);
   for (ShaderList::const_iterator it = shaders_.begin();
         it != shaders_.end(); ++it) {
     if ((*it)->GetDataType() == type) {
       GLES_ERROR(GL_INVALID_OPERATION,
                  "Shader of type '%s' has already been attached",
                  GetEnumString(type));
       return;
     }
   }

   // Add shader to the list and to the currently-built program variant.
   ModifyProgramLocked();
   shaders_.push_back(shader);
   current_program_->AttachShader(shader->GetShaderVariant());
 }

 void ProgramData::DetachShader(const ShaderDataPtr& shader) {
   AutoLock lock(lock_);
   bool found = false;
   for (ShaderList::iterator it = shaders_.begin();
       it != shaders_.end(); ++it) {
     if (shader == *it) {
       shaders_.erase(it);
       found = true;
       break;
     }
   }
   if (!found) {
     GLES_ERROR(GL_INVALID_OPERATION, "The shader has not been attached");
     return;
   }
   ModifyProgramLocked();
   current_program_->DetachShader(shader->GetShaderVariant());
 }

 void ProgramData::GetAttachedShaders(GLsizei max_count, GLsizei* count,
                                      GLuint* shaders) const {
   int i = 0;
   for (ShaderList::const_iterator it = shaders_.begin();
         it != shaders_.end() && i < max_count; ++it) {
     shaders[i] = (*it)->GetLocalName();
     ++i;
   }
   if (count) {
     *count = i;
   }
 }

 ProgramVariantPtr ProgramData::GetProgramWithLinkAttemptLocked() const {
   if (current_program_->IsLinkAttempted()) {
     return current_program_;
   }
   if (!linked_programs_.empty()) {
     return linked_programs_[0].GetProgram();
   }
   return ProgramVariantPtr();
 }

 void ProgramData::GetProgramiv(GLenum pname, GLint* params) const {
   AutoLock lock(lock_);
   switch (pname) {
     case GL_DELETE_STATUS:
       *params = GL_FALSE;  // Not supported (crbug.com/424353).
       break;
     case GL_INFO_LOG_LENGTH:
       *params = current_program_->GetInfoLog().size() + 1;
       break;
     case GL_ATTACHED_SHADERS:
       *params = shaders_.size();
       break;
     case GL_LINK_STATUS:
       *params = (!linked_programs_.empty() && !has_link_failure_ ?
           GL_TRUE : GL_FALSE);
       break;
     case GL_VALIDATE_STATUS:
       *params = validation_status_;
       break;
     case GL_ACTIVE_ATTRIBUTES: {
       ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
       if (program != NULL) {
         *params = program->GetActiveAttribCount();
       } else {
         *params = 0;
       }
       break;
     }
     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: {
       ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
       if (program != NULL) {
         *params = program->GetActiveAttribMaxNameLengh() + 1;
       } else {
         *params = 0;
       }
       break;
     }
     case GL_ACTIVE_UNIFORMS: {
       ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
       if (program != NULL) {
         *params = program->GetActiveUniformCount();
       } else {
         *params = 0;
       }
       break;
     }
     case GL_ACTIVE_UNIFORM_MAX_LENGTH: {
       ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
       if (program != NULL) {
         *params = program->GetActiveUniformMaxNameLengh() + 1;
       } else {
         *params = 0;
       }
       break;
     }
     default:
       GLES_ERROR_INVALID_ENUM(pname);
       break;
   }
 }

 void ProgramData::GetInfoLog(GLsizei max_length, GLsizei* length,
                              GLchar* info_log) const {
   // Use current program as it either equals to the linked program, or may have
   // more recent data if there were GL calls after linking.
   int info_len = snprintf(info_log, max_length, "%s",
                           current_program_->GetInfoLog().c_str());
   if (info_len >= max_length) {
     info_len = max_length - 1;  // Text was truncated.
   }
   if (length) {
     *length = info_len;
   }
 }

 void ProgramData::Link() {
   AutoLock lock(lock_);
   if (current_program_->IsLinked()) {
     return;
   }

   current_program_->Link();
   has_warned_about_sampler_use_ = false;
   has_link_failure_ = !current_program_->IsLinked();
   if (!has_link_failure_) {
     SetLinkedProgramLocked(current_program_);
     return;
   }

   ALOGE("Unable to link program %d(%d)\n%s", GetLocalName(),
         current_program_->GetOrCreateGlobalName(),
         current_program_->GetInfoLog().c_str());

   if (use_count_ == 0) {
     SetLinkedProgramLocked(ProgramVariantPtr(NULL));
   }
 }

 void ProgramData::SetLinkedProgramLocked(ProgramVariantPtr program) {
   // Reset all mappings.
   linked_programs_.clear();
   ClearUniformCacheLocked();

   if (program == NULL) {
     return;  // No linked program exists.
   }

   for (int i = 0; i < program->GetActiveUniformCount(); ++i) {
     const ProgramVariant::ActiveUniform& uniform =
         program->GetActiveUniform(i);
     uniform_cache_[uniform.GetBaseName()] = new CachedUniform(
         uniform.GetType(), uniform.IsArray(), uniform.GetArraySize());
   }

   linked_programs_.push_back(LinkedProgram(program));
 }

 bool ProgramData::Use(bool enable) {
   AutoLock lock(lock_);
   if (!enable) {
     // May be invoked without current context from context destructor.
     --use_count_;
     if (has_link_failure_ && !linked_programs_.empty() && use_count_ == 0) {
       // glUseProgram() spec says an active in-use program that failed
       // to re-link should keep working until it goes out of use.
       SetLinkedProgramLocked(ProgramVariantPtr(NULL));
     }
     return true;
   }
   if (linked_programs_.empty()) {
     GLES_ERROR(GL_INVALID_OPERATION, "Shader program has not been linked");
     return false;
   }
   GetRequiredContext();
   ++use_count_;
   return true;
 }

 void ProgramData::PrepareForRendering(bool* uses_external_as_2d) {
   AutoLock lock(lock_);
   LinkedProgram* program = GetLinkedProgramForRenderingLocked();
   *uses_external_as_2d = program->GetProgram()->UsesExternalTextureAs2D();

   GlesContext* ctx = GetRequiredContext();
   GLint global_program_name = program->GetProgram()->GetOrCreateGlobalName();
   PASS_THROUGH(ctx, UseProgram, global_program_name);

   PropagateUniformValuesLocked(program);
 }

 void ProgramData::CleanupAfterRendering() {
   GlesContext* ctx = GetRequiredContext();
   PASS_THROUGH(ctx, UseProgram, 0);
 }

 ProgramData::LinkedProgram* ProgramData::GetLinkedProgramForRenderingLocked() {
   LOG_ALWAYS_FATAL_IF(linked_programs_.empty());
   LOG_ALWAYS_FATAL_IF(
       linked_programs_[0].GetGlobalTextureTarget() != GL_TEXTURE_2D);

   if (!linked_programs_[0].GetProgram()->UsesExternalTextureAs2D()) {
     // The original program did not use external sampler, cannot rewrite it.
     return &linked_programs_[0];
   }

   // Look for the uniforms that refer appropriate texture units.
   GLint texture_unit_index = -1;
   for (UniformCacheMap::const_iterator it = uniform_cache_.begin();
         it != uniform_cache_.end(); ++it) {
     const CachedUniform* uniform = it->second;
     if (uniform->GetType() != GL_SAMPLER_2D) {
       continue;
     }
     if (uniform->GetArraySize() != 1) {
       if (!has_warned_about_sampler_use_) {
         ALOGW("Shader program uses a sampler array, which is not supported "
               "for backend texture adjustments (used with HW video)");
         has_warned_about_sampler_use_ = true;
       }
       return &linked_programs_[0];
     }
     if (texture_unit_index != -1) {
       if (!has_warned_about_sampler_use_) {
         ALOGW("Shader program uses more than multiple active 2D samplers, "
               "which is not supported for backend texture adjustments "
               "(used with HW video)");
         has_warned_about_sampler_use_ = true;
       }
       return &linked_programs_[0];
     }
     LOG_ALWAYS_FATAL_IF(!uniform->StoreAsIntTo(&texture_unit_index));
   }

   // Find the global target for the sampler's texture.
   GLenum global_target = GL_TEXTURE_2D;
   if (texture_unit_index != -1) {
     GlesContext* ctx = GetRequiredContext();
     global_target = ctx->texture_context_.GetGlobalTarget(
         GL_TEXTURE0 + texture_unit_index, GL_TEXTURE_EXTERNAL_OES);
   }

   // The default program is always targeting GL_TEXTURE_2D.
   if (global_target == GL_TEXTURE_2D) {
     return &linked_programs_[0];
   }

   // Find or create a program for another texture target.
   for (size_t i = 1; i < linked_programs_.size(); ++i) {
     LinkedProgram* program = &linked_programs_[i];
     if (program->GetGlobalTextureTarget() == global_target) {
       return program;
     }
   }

   if (global_target == GL_TEXTURE_EXTERNAL_OES) {
     LinkedProgram* program = linked_programs_[0].Clone(global_target);
     if (!program) {
       if (!has_warned_about_sampler_use_) {
         ALOGW("Unable to rewrite shader program, which is required for "
               "backend texture adjustments (used with HW video)");
         has_warned_about_sampler_use_ = true;
       }
       return &linked_programs_[0];
     }
     linked_programs_.push_back(*program);
     return &linked_programs_[linked_programs_.size() - 1];
   }

   ALOGE("Shader program is used with unsupported texture target %s(0x%x)",
         GetEnumString(global_target), global_target);
   return &linked_programs_[0];
 }

 void ProgramData::Validate() {
   AutoLock lock(lock_);
   if (linked_programs_.empty()) {
     return;
   }

   bool has_stale_uniform_data = false;
   LinkedProgram* program = &linked_programs_[0];
   for (UniformCacheMap::const_iterator it = uniform_cache_.begin();
         it != uniform_cache_.end(); ++it) {
     if (it->second->GetRevision() > program->GetUniformRevision()) {
       has_stale_uniform_data = true;
       break;
     }
   }

   GlesContext* ctx = GetRequiredContext();
   GLint program_name = program->GetProgram()->GetOrCreateGlobalName();
   if (has_stale_uniform_data) {
     PASS_THROUGH(ctx, UseProgram, program_name);
     PropagateUniformValuesLocked(program);
     PASS_THROUGH(ctx, UseProgram, 0);
   }

   PASS_THROUGH(ctx, ValidateProgram, program_name);
   PASS_THROUGH(ctx, GetProgramiv, program_name, GL_VALIDATE_STATUS,
                &validation_status_);
   program->GetProgram()->ResetInfoLogCache();
 }

 ///////////////////////////////////////////////////////////////////////////////
 // Uniform support.
 ///////////////////////////////////////////////////////////////////////////////

 void ProgramData::GetActiveUniform(GLuint index, GLsizei buf_size,
                                    GLsizei* length, GLint* size, GLenum* type,
                                    GLchar* name) const {
   ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
   if (program != NULL) {
     program->GetActiveUniform(index, buf_size, length, size, type, name);
     return;
   }

   GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
 }

 void ProgramData::ClearUniformCacheLocked() {
   for (UniformCacheMap::iterator it = uniform_cache_.begin();
         it != uniform_cache_.end(); ++it) {
     delete it->second;
   }
   uniform_cache_.clear();
   uniform_locations_.clear();
   uniform_revision_gen_ = 0;
 }

 GLint ProgramData::GetUniformLocation(const GLchar* name) {
   AutoLock lock(lock_);
   if (linked_programs_.empty()) {
     GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
     return -1;
   }

   // Look for known local locations.
   for (UniformLocationMap::const_iterator it = uniform_locations_.begin();
         it != uniform_locations_.end(); ++it) {
     if (it->second.GetOriginalName() == name) {
       return it->first;
     }
   }

   // Look up matching active uniform.
   int array_index = -1;
   ProgramVariantPtr program = linked_programs_[0].GetProgram();
   std::string base_name = program->ParseUniformName(name, &array_index);
   if (base_name.empty()) {
     return -1;
   }

   // A sanity check for the location in the underlying shader program.
   GLint global_location = program->GetUniformLocation(name);
   if (global_location == -1) {
     return -1;
   }

   // Add location to the uniform map.
   GLint local_location = ++uniform_location_gen_;
   uniform_locations_[local_location] = UniformLocation(
       name, base_name, array_index);
   return local_location;
 }

 void ProgramData::PropagateUniformValuesLocked(LinkedProgram* program) {
   GlesContext* ctx = GetRequiredContext();
   uint64_t max_revision = 0;
   for (UniformCacheMap::const_iterator it = uniform_cache_.begin();
         it != uniform_cache_.end(); ++it) {
     const CachedUniform* uniform = it->second;
     uint64_t revision = uniform->GetRevision();
     if (revision > max_revision) {
       max_revision = revision;
     }
     if (revision <= program->GetUniformRevision()) {
       continue;
     }
     // Lookup location of the base uniform name, then set the entire value.
     // TODO(crbug.com/441930): Propagate only those array elements that were
     // modified.
     GLint global_location =
         program->GetProgram()->GetUniformLocation(it->first);
     if (global_location == -1) {
       ALOGW("Unable to find global location for uniform '%s'",
             it->first.c_str());
       continue;
     }
     uniform->SetOnProgram(ctx, global_location);
   }
   program->SetUniformRevision(max_revision);
 }

 void ProgramData::SetUniformInternal(GLint location,
                                      const UniformValue& value) {
   AutoLock lock(lock_);
   if (location == -1) {
     return;  // GLES2 requires -1 to be ignored.
   }
   if (!uniform_locations_.count(location)) {
     GLES_ERROR(GL_INVALID_OPERATION,
                "Uniform location unknown or program has not been linked");
     return;
   }

   const UniformLocation& location_info =
       uniform_locations_.find(location)->second;
   UniformCacheMap::iterator it =
       uniform_cache_.find(location_info.GetBaseName());
   LOG_ALWAYS_FATAL_IF(it == uniform_cache_.end());
   CachedUniform* uniform = it->second;

   if (value.IsArray() && !uniform->IsArray()) {
     GLES_ERROR(GL_INVALID_OPERATION,
                "Unable to set uniform with count > 1 on a non-array");
     return;
   }

   for (int i = 0; i < value.GetArraySize(); ++i) {
     int target_array_idx = location_info.GetArrayIndex() + i;
     if (target_array_idx >= uniform->GetArraySize()) {
       break;
     }
     if (!uniform->CopyElementFrom(target_array_idx, value, i)) {
       GLES_ERROR(GL_INVALID_OPERATION, "Unable to convert uniform data");
       return;
     }
   }
   uniform->SetRevision(++uniform_revision_gen_);
 }

 void ProgramData::Uniformfv(GLint location, GLenum type, GLsizei count,
                              const GLfloat* value) {
   if (count < 0) {
     GLES_ERROR_INVALID_VALUE_INT(count);
     return;
   }
   bool is_array = count > 1;
   SetUniformInternal(location, UniformValue(type, is_array, count, value));
 }

 void ProgramData::Uniformiv(GLint location, GLenum type, GLsizei count,
                              const GLint* value) {
   if (count < 0) {
     GLES_ERROR_INVALID_VALUE_INT(count);
     return;
   }
   bool is_array = count > 1;
   SetUniformInternal(location, UniformValue(type, is_array, count, value));
 }

 void ProgramData::UniformMatrixfv(GLint location, GLenum type, GLsizei count,
                                   GLboolean transpose, const GLfloat* value) {
   if (count < 0) {
     GLES_ERROR_INVALID_VALUE_INT(count);
     return;
   }
   if (transpose) {
     GLES_ERROR_INVALID_VALUE_INT(static_cast<int>(transpose));
     return;
   }
   bool is_array = count > 1;
   SetUniformInternal(location, UniformValue(type, is_array, count, value));
 }

 void ProgramData::GetUniformfv(GLint location, GLfloat* params) const {
   AutoLock lock(lock_);
   if (!uniform_locations_.count(location)) {
     GLES_ERROR(GL_INVALID_OPERATION,
                "Uniform location unknown or program has not been linked");
     return;
   }

   const UniformLocation& location_info =
       uniform_locations_.find(location)->second;
   UniformCacheMap::const_iterator it =
       uniform_cache_.find(location_info.GetBaseName());
   LOG_ALWAYS_FATAL_IF(it == uniform_cache_.end());
   if (!it->second->StoreAsFloatTo(params)) {
     GLES_ERROR(GL_INVALID_OPERATION, "Unable to convert uniform data");
   }
 }

 void ProgramData::GetUniformiv(GLint location, GLint* params) const {
   AutoLock lock(lock_);
   if (!uniform_locations_.count(location)) {
     GLES_ERROR(GL_INVALID_OPERATION,
                "Uniform location unknown or program has not been linked");
     return;
   }

   const UniformLocation& location_info =
       uniform_locations_.find(location)->second;
   UniformCacheMap::const_iterator it =
       uniform_cache_.find(location_info.GetBaseName());
   LOG_ALWAYS_FATAL_IF(it == uniform_cache_.end());
   if (!it->second->StoreAsIntTo(params)) {
     GLES_ERROR(GL_INVALID_OPERATION, "Unable to convert uniform data");
   }
 }

 ///////////////////////////////////////////////////////////////////////////////
 // Attribute support.
 ///////////////////////////////////////////////////////////////////////////////

 void ProgramData::GetActiveAttrib(GLuint index, GLsizei buf_size,
                                   GLsizei* length, GLint* size,
                                   GLenum* type, GLchar* name) const {
   ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
   if (program != NULL) {
     program->GetActiveAttrib(index, buf_size, length, size, type, name);
     return;
   }

   GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
 }

 void ProgramData::BindAttribLocation(GLuint index, const GLchar* name) {
   AutoLock lock(lock_);
   // Binding of attributes can only happen before linking.
   ModifyProgramLocked();
   current_program_->BindAttribLocation(name, index);
 }

 GLint ProgramData::GetAttribLocation(const GLchar* name) {
   AutoLock lock(lock_);
   if (linked_programs_.empty()) {
     GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
     return -1;
   }
   return linked_programs_[0].GetProgram()->GetAttribLocation(name);
 }

 ///////////////////////////////////////////////////////////////////////////////
 // CachedUniform
 ///////////////////////////////////////////////////////////////////////////////

 bool ProgramData::CachedUniform::CopyElementFrom(int dst_idx,
                                                  const UniformValue& src,
                                                  int src_idx) {
   return value_.CopyElementFrom(dst_idx, src, src_idx);
 }

 bool ProgramData::CachedUniform::StoreAsFloatTo(GLfloat* value) const {
   return value_.StoreAsFloatTo(value);
 }

 bool ProgramData::CachedUniform::StoreAsIntTo(GLint* value) const {
   return value_.StoreAsIntTo(value);
 }

 void ProgramData::CachedUniform::SetOnProgram(GlesContext* ctx,
                                               GLuint global_location) const {
   value_.SetOnProgram(ctx, global_location);
 }

 ///////////////////////////////////////////////////////////////////////////////
 // LinkedProgram
 ///////////////////////////////////////////////////////////////////////////////

 ProgramData::LinkedProgram::LinkedProgram(ProgramVariantPtr program)
     : program_(program), uniform_revision_(0) {
   LOG_ALWAYS_FATAL_IF(program_ == NULL);
   LOG_ALWAYS_FATAL_IF(!program_->IsLinked());
 }

 ProgramData::LinkedProgram* ProgramData::LinkedProgram::Clone(
     GLenum global_texture_target) const {
   if (!program_->UsesExternalTextureAs2D()) {
     // It is not possible to use other global targets if the user's program
     // does not use external textures.
     return NULL;
   }

   // Create the new program with proper shaders.
   ProgramVariantPtr new_program = ProgramVariantPtr(new ProgramVariant());
   new_program->AttachShader(program_->GetVertexShader());
   ShaderVariantPtr fragment_shader = ShaderVariantPtr(
       new ShaderVariant(FRAGMENT_SHADER));
   fragment_shader->SetGlobalTextureTarget(global_texture_target);
   fragment_shader->SetSource(
       program_->GetFragmentShader()->GetOriginalSource());
   fragment_shader->Compile();
   new_program->AttachShader(fragment_shader);

 #ifdef ENABLE_API_LOGGING
   ALOGI("Rewrote fragment shader old_name=%d new_name=%d:\n"
          "--- Original Source ---\n%s\n"
          "--- Modified Source ---\n%s\n"
          "---  End of Source  ---\n",
          program_->GetFragmentShader()->GetOrCreateGlobalName(),
          fragment_shader->GetOrCreateGlobalName(),
          fragment_shader->GetOriginalSource().c_str(),
          fragment_shader->GetUpdatedSource().c_str());
 #endif

   // Transfer vertex attribute bindings as they refer to app's GL context.
   for (int i = 0; i < program_->GetActiveAttribCount(); ++i) {
     GLint location = -1;
     std::string name = program_->GetActiveAttribNameAndLocation(i, &location);
     if (location != -1) {
       new_program->BindAttribLocation(name, location);
     }
   }

   // Link the new program.
   new_program->Link();
   if (!new_program->IsLinked()) {
     ALOGW("Unable to link program for texture target 0x%x",
           global_texture_target);
     return NULL;
   }

   return new LinkedProgram(new_program);
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "gles/program_data.h"

	#include <stdio.h>
	#include <GLES/glext.h>

	#include "common/alog.h"
	#include "gles/debug.h"
	#include "gles/gles_context.h"
	#include "gles/macros.h"
	#include "gles/shader_data.h"

	using android::base::AutoLock;

	static GlesContext* GetRequiredContext() {
	GlesContext* ctx = GetCurrentGlesContext();
	LOG_ALWAYS_FATAL_IF(!ctx);
	return ctx;
	}

	ProgramData::ProgramData(ObjectLocalName name)
	: ObjectData(PROGRAM, name), current_program_(new ProgramVariant()),
	uniform_location_gen_(0), has_link_failure_(false),
	has_warned_about_sampler_use_(false), use_count_(0),
	uniform_revision_gen_(0), validation_status_(GL_FALSE) {
	}

	ProgramData::~ProgramData() {
	if (use_count_) {
	ALOGE("ProgramData destroyed while use count is %d", use_count_);
	}
	ClearUniformCacheLocked();
	}

	void ProgramData::ModifyProgramLocked() {
	if (linked_programs_.empty() \|\|
	current_program_ != linked_programs_[0].GetProgram()) {
	return; // Already modifying a new program variant.
	}
	// The program has been linked and may be in use. Create a new one.
	current_program_ = ProgramVariantPtr(
	linked_programs_[0].GetProgram()->Clone());
	// TODO(crbug.com/441928): Support a case where a linked program gets
	// modified, its compiled shader is re-attached, and then shader source
	// is updated.
	}

	void ProgramData::AttachShader(const ShaderDataPtr& shader) {
	AutoLock lock(lock_);
	// Check type correctness and that there is no existing shader with that type.
	ObjectType type = shader->GetDataType();
	LOG_ALWAYS_FATAL_IF(type != VERTEX_SHADER && type != FRAGMENT_SHADER);
	for (ShaderList::const_iterator it = shaders_.begin();
	it != shaders_.end(); ++it) {
	if ((*it)->GetDataType() == type) {
	GLES_ERROR(GL_INVALID_OPERATION,
	"Shader of type '%s' has already been attached",
	GetEnumString(type));
	return;
	}
	}

	// Add shader to the list and to the currently-built program variant.
	ModifyProgramLocked();
	shaders_.push_back(shader);
	current_program_->AttachShader(shader->GetShaderVariant());
	}

	void ProgramData::DetachShader(const ShaderDataPtr& shader) {
	AutoLock lock(lock_);
	bool found = false;
	for (ShaderList::iterator it = shaders_.begin();
	it != shaders_.end(); ++it) {
	if (shader == *it) {
	shaders_.erase(it);
	found = true;
	break;
	}
	}
	if (!found) {
	GLES_ERROR(GL_INVALID_OPERATION, "The shader has not been attached");
	return;
	}
	ModifyProgramLocked();
	current_program_->DetachShader(shader->GetShaderVariant());
	}

	void ProgramData::GetAttachedShaders(GLsizei max_count, GLsizei* count,
	GLuint* shaders) const {
	int i = 0;
	for (ShaderList::const_iterator it = shaders_.begin();
	it != shaders_.end() && i < max_count; ++it) {
	shaders[i] = (*it)->GetLocalName();
	++i;
	}
	if (count) {
	*count = i;
	}
	}

	ProgramVariantPtr ProgramData::GetProgramWithLinkAttemptLocked() const {
	if (current_program_->IsLinkAttempted()) {
	return current_program_;
	}
	if (!linked_programs_.empty()) {
	return linked_programs_[0].GetProgram();
	}
	return ProgramVariantPtr();
	}

	void ProgramData::GetProgramiv(GLenum pname, GLint* params) const {
	AutoLock lock(lock_);
	switch (pname) {
	case GL_DELETE_STATUS:
	*params = GL_FALSE; // Not supported (crbug.com/424353).
	break;
	case GL_INFO_LOG_LENGTH:
	*params = current_program_->GetInfoLog().size() + 1;
	break;
	case GL_ATTACHED_SHADERS:
	*params = shaders_.size();
	break;
	case GL_LINK_STATUS:
	*params = (!linked_programs_.empty() && !has_link_failure_ ?
	GL_TRUE : GL_FALSE);
	break;
	case GL_VALIDATE_STATUS:
	*params = validation_status_;
	break;
	case GL_ACTIVE_ATTRIBUTES: {
	ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
	if (program != NULL) {
	*params = program->GetActiveAttribCount();
	} else {
	*params = 0;
	}
	break;
	}
	case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: {
	ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
	if (program != NULL) {
	*params = program->GetActiveAttribMaxNameLengh() + 1;
	} else {
	*params = 0;
	}
	break;
	}
	case GL_ACTIVE_UNIFORMS: {
	ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
	if (program != NULL) {
	*params = program->GetActiveUniformCount();
	} else {
	*params = 0;
	}
	break;
	}
	case GL_ACTIVE_UNIFORM_MAX_LENGTH: {
	ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
	if (program != NULL) {
	*params = program->GetActiveUniformMaxNameLengh() + 1;
	} else {
	*params = 0;
	}
	break;
	}
	default:
	GLES_ERROR_INVALID_ENUM(pname);
	break;
	}
	}

	void ProgramData::GetInfoLog(GLsizei max_length, GLsizei* length,
	GLchar* info_log) const {
	// Use current program as it either equals to the linked program, or may have
	// more recent data if there were GL calls after linking.
	int info_len = snprintf(info_log, max_length, "%s",
	current_program_->GetInfoLog().c_str());
	if (info_len >= max_length) {
	info_len = max_length - 1; // Text was truncated.
	}
	if (length) {
	*length = info_len;
	}
	}

	void ProgramData::Link() {
	AutoLock lock(lock_);
	if (current_program_->IsLinked()) {
	return;
	}

	current_program_->Link();
	has_warned_about_sampler_use_ = false;
	has_link_failure_ = !current_program_->IsLinked();
	if (!has_link_failure_) {
	SetLinkedProgramLocked(current_program_);
	return;
	}

	ALOGE("Unable to link program %d(%d)\n%s", GetLocalName(),
	current_program_->GetOrCreateGlobalName(),
	current_program_->GetInfoLog().c_str());

	if (use_count_ == 0) {
	SetLinkedProgramLocked(ProgramVariantPtr(NULL));
	}
	}

	void ProgramData::SetLinkedProgramLocked(ProgramVariantPtr program) {
	// Reset all mappings.
	linked_programs_.clear();
	ClearUniformCacheLocked();

	if (program == NULL) {
	return; // No linked program exists.
	}

	for (int i = 0; i < program->GetActiveUniformCount(); ++i) {
	const ProgramVariant::ActiveUniform& uniform =
	program->GetActiveUniform(i);
	uniform_cache_[uniform.GetBaseName()] = new CachedUniform(
	uniform.GetType(), uniform.IsArray(), uniform.GetArraySize());
	}

	linked_programs_.push_back(LinkedProgram(program));
	}

	bool ProgramData::Use(bool enable) {
	AutoLock lock(lock_);
	if (!enable) {
	// May be invoked without current context from context destructor.
	--use_count_;
	if (has_link_failure_ && !linked_programs_.empty() && use_count_ == 0) {
	// glUseProgram() spec says an active in-use program that failed
	// to re-link should keep working until it goes out of use.
	SetLinkedProgramLocked(ProgramVariantPtr(NULL));
	}
	return true;
	}
	if (linked_programs_.empty()) {
	GLES_ERROR(GL_INVALID_OPERATION, "Shader program has not been linked");
	return false;
	}
	GetRequiredContext();
	++use_count_;
	return true;
	}

	void ProgramData::PrepareForRendering(bool* uses_external_as_2d) {
	AutoLock lock(lock_);
	LinkedProgram* program = GetLinkedProgramForRenderingLocked();
	*uses_external_as_2d = program->GetProgram()->UsesExternalTextureAs2D();

	GlesContext* ctx = GetRequiredContext();
	GLint global_program_name = program->GetProgram()->GetOrCreateGlobalName();
	PASS_THROUGH(ctx, UseProgram, global_program_name);

	PropagateUniformValuesLocked(program);
	}

	void ProgramData::CleanupAfterRendering() {
	GlesContext* ctx = GetRequiredContext();
	PASS_THROUGH(ctx, UseProgram, 0);
	}

	ProgramData::LinkedProgram* ProgramData::GetLinkedProgramForRenderingLocked() {
	LOG_ALWAYS_FATAL_IF(linked_programs_.empty());
	LOG_ALWAYS_FATAL_IF(
	linked_programs_[0].GetGlobalTextureTarget() != GL_TEXTURE_2D);

	if (!linked_programs_[0].GetProgram()->UsesExternalTextureAs2D()) {
	// The original program did not use external sampler, cannot rewrite it.
	return &linked_programs_[0];
	}

	// Look for the uniforms that refer appropriate texture units.
	GLint texture_unit_index = -1;
	for (UniformCacheMap::const_iterator it = uniform_cache_.begin();
	it != uniform_cache_.end(); ++it) {
	const CachedUniform* uniform = it->second;
	if (uniform->GetType() != GL_SAMPLER_2D) {
	continue;
	}
	if (uniform->GetArraySize() != 1) {
	if (!has_warned_about_sampler_use_) {
	ALOGW("Shader program uses a sampler array, which is not supported "
	"for backend texture adjustments (used with HW video)");
	has_warned_about_sampler_use_ = true;
	}
	return &linked_programs_[0];
	}
	if (texture_unit_index != -1) {
	if (!has_warned_about_sampler_use_) {
	ALOGW("Shader program uses more than multiple active 2D samplers, "
	"which is not supported for backend texture adjustments "
	"(used with HW video)");
	has_warned_about_sampler_use_ = true;
	}
	return &linked_programs_[0];
	}
	LOG_ALWAYS_FATAL_IF(!uniform->StoreAsIntTo(&texture_unit_index));
	}

	// Find the global target for the sampler's texture.
	GLenum global_target = GL_TEXTURE_2D;
	if (texture_unit_index != -1) {
	GlesContext* ctx = GetRequiredContext();
	global_target = ctx->texture_context_.GetGlobalTarget(
	GL_TEXTURE0 + texture_unit_index, GL_TEXTURE_EXTERNAL_OES);
	}

	// The default program is always targeting GL_TEXTURE_2D.
	if (global_target == GL_TEXTURE_2D) {
	return &linked_programs_[0];
	}

	// Find or create a program for another texture target.
	for (size_t i = 1; i < linked_programs_.size(); ++i) {
	LinkedProgram* program = &linked_programs_[i];
	if (program->GetGlobalTextureTarget() == global_target) {
	return program;
	}
	}

	if (global_target == GL_TEXTURE_EXTERNAL_OES) {
	LinkedProgram* program = linked_programs_[0].Clone(global_target);
	if (!program) {
	if (!has_warned_about_sampler_use_) {
	ALOGW("Unable to rewrite shader program, which is required for "
	"backend texture adjustments (used with HW video)");
	has_warned_about_sampler_use_ = true;
	}
	return &linked_programs_[0];
	}
	linked_programs_.push_back(*program);
	return &linked_programs_[linked_programs_.size() - 1];
	}

	ALOGE("Shader program is used with unsupported texture target %s(0x%x)",
	GetEnumString(global_target), global_target);
	return &linked_programs_[0];
	}

	void ProgramData::Validate() {
	AutoLock lock(lock_);
	if (linked_programs_.empty()) {
	return;
	}

	bool has_stale_uniform_data = false;
	LinkedProgram* program = &linked_programs_[0];
	for (UniformCacheMap::const_iterator it = uniform_cache_.begin();
	it != uniform_cache_.end(); ++it) {
	if (it->second->GetRevision() > program->GetUniformRevision()) {
	has_stale_uniform_data = true;
	break;
	}
	}

	GlesContext* ctx = GetRequiredContext();
	GLint program_name = program->GetProgram()->GetOrCreateGlobalName();
	if (has_stale_uniform_data) {
	PASS_THROUGH(ctx, UseProgram, program_name);
	PropagateUniformValuesLocked(program);
	PASS_THROUGH(ctx, UseProgram, 0);
	}

	PASS_THROUGH(ctx, ValidateProgram, program_name);
	PASS_THROUGH(ctx, GetProgramiv, program_name, GL_VALIDATE_STATUS,
	&validation_status_);
	program->GetProgram()->ResetInfoLogCache();
	}

	///////////////////////////////////////////////////////////////////////////////
	// Uniform support.
	///////////////////////////////////////////////////////////////////////////////

	void ProgramData::GetActiveUniform(GLuint index, GLsizei buf_size,
	GLsizei* length, GLint* size, GLenum* type,
	GLchar* name) const {
	ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
	if (program != NULL) {
	program->GetActiveUniform(index, buf_size, length, size, type, name);
	return;
	}

	GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
	}

	void ProgramData::ClearUniformCacheLocked() {
	for (UniformCacheMap::iterator it = uniform_cache_.begin();
	it != uniform_cache_.end(); ++it) {
	delete it->second;
	}
	uniform_cache_.clear();
	uniform_locations_.clear();
	uniform_revision_gen_ = 0;
	}

	GLint ProgramData::GetUniformLocation(const GLchar* name) {
	AutoLock lock(lock_);
	if (linked_programs_.empty()) {
	GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
	return -1;
	}

	// Look for known local locations.
	for (UniformLocationMap::const_iterator it = uniform_locations_.begin();
	it != uniform_locations_.end(); ++it) {
	if (it->second.GetOriginalName() == name) {
	return it->first;
	}
	}

	// Look up matching active uniform.
	int array_index = -1;
	ProgramVariantPtr program = linked_programs_[0].GetProgram();
	std::string base_name = program->ParseUniformName(name, &array_index);
	if (base_name.empty()) {
	return -1;
	}

	// A sanity check for the location in the underlying shader program.
	GLint global_location = program->GetUniformLocation(name);
	if (global_location == -1) {
	return -1;
	}

	// Add location to the uniform map.
	GLint local_location = ++uniform_location_gen_;
	uniform_locations_[local_location] = UniformLocation(
	name, base_name, array_index);
	return local_location;
	}

	void ProgramData::PropagateUniformValuesLocked(LinkedProgram* program) {
	GlesContext* ctx = GetRequiredContext();
	uint64_t max_revision = 0;
	for (UniformCacheMap::const_iterator it = uniform_cache_.begin();
	it != uniform_cache_.end(); ++it) {
	const CachedUniform* uniform = it->second;
	uint64_t revision = uniform->GetRevision();
	if (revision > max_revision) {
	max_revision = revision;
	}
	if (revision <= program->GetUniformRevision()) {
	continue;
	}
	// Lookup location of the base uniform name, then set the entire value.
	// TODO(crbug.com/441930): Propagate only those array elements that were
	// modified.
	GLint global_location =
	program->GetProgram()->GetUniformLocation(it->first);
	if (global_location == -1) {
	ALOGW("Unable to find global location for uniform '%s'",
	it->first.c_str());
	continue;
	}
	uniform->SetOnProgram(ctx, global_location);
	}
	program->SetUniformRevision(max_revision);
	}

	void ProgramData::SetUniformInternal(GLint location,
	const UniformValue& value) {
	AutoLock lock(lock_);
	if (location == -1) {
	return; // GLES2 requires -1 to be ignored.
	}
	if (!uniform_locations_.count(location)) {
	GLES_ERROR(GL_INVALID_OPERATION,
	"Uniform location unknown or program has not been linked");
	return;
	}

	const UniformLocation& location_info =
	uniform_locations_.find(location)->second;
	UniformCacheMap::iterator it =
	uniform_cache_.find(location_info.GetBaseName());
	LOG_ALWAYS_FATAL_IF(it == uniform_cache_.end());
	CachedUniform* uniform = it->second;

	if (value.IsArray() && !uniform->IsArray()) {
	GLES_ERROR(GL_INVALID_OPERATION,
	"Unable to set uniform with count > 1 on a non-array");
	return;
	}

	for (int i = 0; i < value.GetArraySize(); ++i) {
	int target_array_idx = location_info.GetArrayIndex() + i;
	if (target_array_idx >= uniform->GetArraySize()) {
	break;
	}
	if (!uniform->CopyElementFrom(target_array_idx, value, i)) {
	GLES_ERROR(GL_INVALID_OPERATION, "Unable to convert uniform data");
	return;
	}
	}
	uniform->SetRevision(++uniform_revision_gen_);
	}

	void ProgramData::Uniformfv(GLint location, GLenum type, GLsizei count,
	const GLfloat* value) {
	if (count < 0) {
	GLES_ERROR_INVALID_VALUE_INT(count);
	return;
	}
	bool is_array = count > 1;
	SetUniformInternal(location, UniformValue(type, is_array, count, value));
	}

	void ProgramData::Uniformiv(GLint location, GLenum type, GLsizei count,
	const GLint* value) {
	if (count < 0) {
	GLES_ERROR_INVALID_VALUE_INT(count);
	return;
	}
	bool is_array = count > 1;
	SetUniformInternal(location, UniformValue(type, is_array, count, value));
	}

	void ProgramData::UniformMatrixfv(GLint location, GLenum type, GLsizei count,
	GLboolean transpose, const GLfloat* value) {
	if (count < 0) {
	GLES_ERROR_INVALID_VALUE_INT(count);
	return;
	}
	if (transpose) {
	GLES_ERROR_INVALID_VALUE_INT(static_cast<int>(transpose));
	return;
	}
	bool is_array = count > 1;
	SetUniformInternal(location, UniformValue(type, is_array, count, value));
	}

	void ProgramData::GetUniformfv(GLint location, GLfloat* params) const {
	AutoLock lock(lock_);
	if (!uniform_locations_.count(location)) {
	GLES_ERROR(GL_INVALID_OPERATION,
	"Uniform location unknown or program has not been linked");
	return;
	}

	const UniformLocation& location_info =
	uniform_locations_.find(location)->second;
	UniformCacheMap::const_iterator it =
	uniform_cache_.find(location_info.GetBaseName());
	LOG_ALWAYS_FATAL_IF(it == uniform_cache_.end());
	if (!it->second->StoreAsFloatTo(params)) {
	GLES_ERROR(GL_INVALID_OPERATION, "Unable to convert uniform data");
	}
	}

	void ProgramData::GetUniformiv(GLint location, GLint* params) const {
	AutoLock lock(lock_);
	if (!uniform_locations_.count(location)) {
	GLES_ERROR(GL_INVALID_OPERATION,
	"Uniform location unknown or program has not been linked");
	return;
	}

	const UniformLocation& location_info =
	uniform_locations_.find(location)->second;
	UniformCacheMap::const_iterator it =
	uniform_cache_.find(location_info.GetBaseName());
	LOG_ALWAYS_FATAL_IF(it == uniform_cache_.end());
	if (!it->second->StoreAsIntTo(params)) {
	GLES_ERROR(GL_INVALID_OPERATION, "Unable to convert uniform data");
	}
	}

	///////////////////////////////////////////////////////////////////////////////
	// Attribute support.
	///////////////////////////////////////////////////////////////////////////////

	void ProgramData::GetActiveAttrib(GLuint index, GLsizei buf_size,
	GLsizei* length, GLint* size,
	GLenum* type, GLchar* name) const {
	ProgramVariantPtr program = GetProgramWithLinkAttemptLocked();
	if (program != NULL) {
	program->GetActiveAttrib(index, buf_size, length, size, type, name);
	return;
	}

	GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
	}

	void ProgramData::BindAttribLocation(GLuint index, const GLchar* name) {
	AutoLock lock(lock_);
	// Binding of attributes can only happen before linking.
	ModifyProgramLocked();
	current_program_->BindAttribLocation(name, index);
	}

	GLint ProgramData::GetAttribLocation(const GLchar* name) {
	AutoLock lock(lock_);
	if (linked_programs_.empty()) {
	GLES_ERROR(GL_INVALID_OPERATION, "The program has not been linked");
	return -1;
	}
	return linked_programs_[0].GetProgram()->GetAttribLocation(name);
	}

	///////////////////////////////////////////////////////////////////////////////
	// CachedUniform
	///////////////////////////////////////////////////////////////////////////////

	bool ProgramData::CachedUniform::CopyElementFrom(int dst_idx,
	const UniformValue& src,
	int src_idx) {
	return value_.CopyElementFrom(dst_idx, src, src_idx);
	}

	bool ProgramData::CachedUniform::StoreAsFloatTo(GLfloat* value) const {
	return value_.StoreAsFloatTo(value);
	}

	bool ProgramData::CachedUniform::StoreAsIntTo(GLint* value) const {
	return value_.StoreAsIntTo(value);
	}

	void ProgramData::CachedUniform::SetOnProgram(GlesContext* ctx,
	GLuint global_location) const {
	value_.SetOnProgram(ctx, global_location);
	}

	///////////////////////////////////////////////////////////////////////////////
	// LinkedProgram
	///////////////////////////////////////////////////////////////////////////////

	ProgramData::LinkedProgram::LinkedProgram(ProgramVariantPtr program)
	: program_(program), uniform_revision_(0) {
	LOG_ALWAYS_FATAL_IF(program_ == NULL);
	LOG_ALWAYS_FATAL_IF(!program_->IsLinked());
	}

	ProgramData::LinkedProgram* ProgramData::LinkedProgram::Clone(
	GLenum global_texture_target) const {
	if (!program_->UsesExternalTextureAs2D()) {
	// It is not possible to use other global targets if the user's program
	// does not use external textures.
	return NULL;
	}

	// Create the new program with proper shaders.
	ProgramVariantPtr new_program = ProgramVariantPtr(new ProgramVariant());
	new_program->AttachShader(program_->GetVertexShader());
	ShaderVariantPtr fragment_shader = ShaderVariantPtr(
	new ShaderVariant(FRAGMENT_SHADER));
	fragment_shader->SetGlobalTextureTarget(global_texture_target);
	fragment_shader->SetSource(
	program_->GetFragmentShader()->GetOriginalSource());
	fragment_shader->Compile();
	new_program->AttachShader(fragment_shader);

	#ifdef ENABLE_API_LOGGING
	ALOGI("Rewrote fragment shader old_name=%d new_name=%d:\n"
	"--- Original Source ---\n%s\n"
	"--- Modified Source ---\n%s\n"
	"--- End of Source ---\n",
	program_->GetFragmentShader()->GetOrCreateGlobalName(),
	fragment_shader->GetOrCreateGlobalName(),
	fragment_shader->GetOriginalSource().c_str(),
	fragment_shader->GetUpdatedSource().c_str());
	#endif

	// Transfer vertex attribute bindings as they refer to app's GL context.
	for (int i = 0; i < program_->GetActiveAttribCount(); ++i) {
	GLint location = -1;
	std::string name = program_->GetActiveAttribNameAndLocation(i, &location);
	if (location != -1) {
	new_program->BindAttribLocation(name, location);
	}
	}

	// Link the new program.
	new_program->Link();
	if (!new_program->IsLinked()) {
	ALOGW("Unable to link program for texture target 0x%x",
	global_texture_target);
	return NULL;
	}

	return new LinkedProgram(new_program);
	}