mca/filterfw/native/core/native_program.cpp

   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: Could not find library: '%s'!", lib_name.c_str());
  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