1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <dlfcn.h> 18 19 #include "base/logging.h" 20 #include "core/native_frame.h" 21 #include "core/native_program.h" 22 23 #include <string> 24 #include <vector> 25 26 namespace android { 27 namespace filterfw { 28 29 NativeProgram::NativeProgram() 30 : lib_handle_(NULL), 31 init_function_(NULL), 32 setvalue_function_(NULL), 33 getvalue_function_(NULL), 34 process_function_(NULL), 35 reset_function_(NULL), 36 teardown_function_(NULL), 37 user_data_(NULL) { 38 } 39 40 NativeProgram::~NativeProgram() { 41 if (lib_handle_) 42 dlclose(lib_handle_); 43 } 44 45 bool NativeProgram::OpenLibrary(const std::string& lib_name) { 46 if (!lib_handle_) { 47 lib_handle_ = dlopen(lib_name.c_str(), RTLD_NOW); 48 if (!lib_handle_) { 49 LOGE("NativeProgram: Error opening library: '%s': %s", lib_name.c_str(), dlerror()); 50 return false; 51 } 52 return true; 53 } 54 return false; 55 } 56 57 bool NativeProgram::BindProcessFunction(const std::string& func_name) { 58 if (!lib_handle_) 59 return false; 60 process_function_ = reinterpret_cast<ProcessFunctionPtr>(dlsym(lib_handle_, func_name.c_str())); 61 if (!process_function_) { 62 LOGE("NativeProgram: Could not find process function symbol: '%s'!", func_name.c_str()); 63 return false; 64 } 65 return true; 66 } 67 68 bool NativeProgram::BindInitFunction(const std::string& func_name) { 69 if (!lib_handle_) 70 return false; 71 init_function_ = reinterpret_cast<InitFunctionPtr>(dlsym(lib_handle_, func_name.c_str())); 72 return init_function_ != NULL; 73 } 74 75 bool NativeProgram::BindSetValueFunction(const std::string& func_name) { 76 if (!lib_handle_) 77 return false; 78 setvalue_function_ = reinterpret_cast<SetValueFunctionPtr>(dlsym(lib_handle_, func_name.c_str())); 79 return setvalue_function_ != NULL; 80 } 81 82 bool NativeProgram::BindGetValueFunction(const std::string& func_name) { 83 if (!lib_handle_) 84 return false; 85 getvalue_function_ = reinterpret_cast<GetValueFunctionPtr>(dlsym(lib_handle_, func_name.c_str())); 86 return getvalue_function_ != NULL; 87 } 88 89 bool NativeProgram::BindResetFunction(const std::string& func_name) { 90 if (!lib_handle_) 91 return false; 92 reset_function_ = reinterpret_cast<ResetFunctionPtr>(dlsym(lib_handle_, func_name.c_str())); 93 return reset_function_ != NULL; 94 } 95 96 bool NativeProgram::BindTeardownFunction(const std::string& func_name) { 97 if (!lib_handle_) 98 return false; 99 teardown_function_ = reinterpret_cast<TeardownFunctionPtr>(dlsym(lib_handle_, func_name.c_str())); 100 return teardown_function_ != NULL; 101 } 102 103 bool NativeProgram::CallProcess(const std::vector<const char*>& inputs, 104 const std::vector<int>& input_sizes, 105 char* output, 106 int output_size) { 107 if (process_function_) { 108 return process_function_(const_cast<const char**>(&inputs[0]), 109 &input_sizes[0], 110 inputs.size(), 111 output, 112 output_size, 113 user_data_) == 1; 114 } 115 return false; 116 } 117 118 bool NativeProgram::CallInit() { 119 if (init_function_) { 120 init_function_(&user_data_); 121 return true; 122 } 123 return false; 124 } 125 126 bool NativeProgram::CallSetValue(const std::string& key, const std::string& value) { 127 if (setvalue_function_) { 128 setvalue_function_(key.c_str(), value.c_str(), user_data_); 129 return true; 130 } 131 return false; 132 } 133 134 std::string NativeProgram::CallGetValue(const std::string& key) { 135 if (getvalue_function_) { 136 static const int buffer_size = 1024; 137 char result[buffer_size]; 138 result[buffer_size - 1] = '\0'; 139 getvalue_function_(key.c_str(), result, buffer_size, user_data_); 140 return std::string(result); 141 } 142 return std::string(); 143 } 144 145 bool NativeProgram::CallReset() { 146 if (reset_function_) { 147 reset_function_(user_data_); 148 return true; 149 } 150 return false; 151 } 152 153 bool NativeProgram::CallTeardown() { 154 if (teardown_function_) { 155 teardown_function_(user_data_); 156 return true; 157 } 158 return false; 159 } 160 161 } // namespace filterfw 162 } // namespace android 163