import("//tizen_src/build/config/tizen_features.gni")
-config("aifw-api") {
- if (tizen_ai) {
- libs = [ "aifw_api_vision_xr_adapter" ]
- }
-}
-
tizen_pkg_config("libaifw-api") {
packages = []
if (tizen_ai) {
#include "base/json/json_writer.h"
#include "media/base/format_utils.h"
#include "tizen_src/chromium_impl/webai/common/ai_logger.h"
+#include "webai/content/dlibwrapper.h"
namespace {
} // namespace
namespace content {
-
void AiProcessorVideoImpl::AdapterDeleter::operator()(xr_adapter_h adapter) {
- CheckResult(xr_adapter_destroy(adapter), AIFW_RESULT_SUCCESS, false);
+ auto fun = reinterpret_cast<xr_adapter_destroy>(
+ Dlibwapper::Getinstance()->Getxrfwapi("xr_adapter_destroy"));
+ if (fun) {
+ CheckResult(fun(adapter), AIFW_RESULT_SUCCESS, false);
+ }
}
AiProcessorVideoImpl::AiProcessorVideoImpl(
TRACE_EVENT0("webai", "AiProcessorVideoImpl::AiProcessorVideoImpl");
task_runner_ = base::SequencedTaskRunner::GetCurrentDefault();
xr_adapter_h handle{};
- CheckResult(xr_adapter_create(&handle), AIFW_RESULT_SUCCESS, false);
+ auto fun = reinterpret_cast<xr_adapter_create>(
+ Dlibwapper::Getinstance()->Getxrfwapi("xr_adapter_create"));
+ if (fun) {
+ CheckResult(fun(&handle), AIFW_RESULT_SUCCESS, false);
+ }
adapter_.reset(handle);
state_ = AdapterState::kStopped;
}
}
TRACE_EVENT_BEGIN0("webai", "xr_adapter_submit_packet");
- CheckResult(xr_adapter_submit_packet(adapter_.get(), input_buffer->packet(),
- output_buffer->packet()),
- AIFW_RESULT_SUCCESS, false);
+
+ auto fun = reinterpret_cast<xr_adapter_submit_packet>(
+ Dlibwapper::Getinstance()->Getxrfwapi("xr_adapter_submit_packet"));
+ if (fun) {
+ CheckResult(
+ fun(adapter_.get(), input_buffer->packet(), output_buffer->packet()),
+ AIFW_RESULT_SUCCESS, false);
+ }
TRACE_EVENT_END0("webai", "xr_adapter_submit_packet");
}
{
TRACE_EVENT0("webai", "xr_adapter_set_frame_ready_cb");
- CheckResult(
- xr_adapter_set_frame_ready_cb(adapter_.get(), XrFrameReadyCb, this),
- AIFW_RESULT_SUCCESS, false);
+
+ auto fun = reinterpret_cast<xr_adapter_set_frame_ready_cb>(
+ Dlibwapper::Getinstance()->Getxrfwapi("xr_adapter_set_frame_ready_cb"));
+ if (fun) {
+ CheckResult(fun(adapter_.get(), XrFrameReadyCb, this),
+ AIFW_RESULT_SUCCESS, false);
+ }
}
CheckResult(CreateJsonConfiguration(configure), true, false);
-
{
TRACE_EVENT0("webai", "xr_adapter_init");
- CheckResult(xr_adapter_init(adapter_.get(), config_json_.value().c_str(),
- config_json_.value().length()),
- AIFW_RESULT_SUCCESS, false);
+ auto fun = reinterpret_cast<xr_adapter_init>(
+ Dlibwapper::Getinstance()->Getxrfwapi("xr_adapter_init"));
+ if (fun) {
+ CheckResult(fun(adapter_.get(), config_json_.value().c_str(),
+ config_json_.value().length()),
+ AIFW_RESULT_SUCCESS, false);
+ }
}
cfg_ = configure;
buffer_pool_ = base::MakeRefCounted<AiVideoFrameBufferPool>();
AI_LOG(ERROR) << "Invalid state:" << static_cast<int>(state_);
return;
}
-
- CheckResult(xr_adapter_deinit(adapter_.get()), AIFW_RESULT_SUCCESS, true);
+ auto fun = reinterpret_cast<xr_adapter_deinit>(
+ Dlibwapper::Getinstance()->Getxrfwapi("xr_adapter_deinit"));
+ if (fun) {
+ CheckResult(fun(adapter_.get()), AIFW_RESULT_SUCCESS, true);
+ }
// Release all buffers.
constexpr gfx::Size max_size{4096, 4096};
#include "tizen_src/chromium_impl/webai/content/ai_impl_base.h"
#include "tizen_src/chromium_impl/webai/content/ai_video_frame_buffer.h"
-#include <aifw_api/vision/xr_adapter.h>
-
namespace content {
class AiProcessorVideoImpl;
} // namespace content
-#endif // WEBAI_CONTENT_AI_PROCESSOR_VIDEO_IMPL_H_
\ No newline at end of file
+#endif // WEBAI_CONTENT_AI_PROCESSOR_VIDEO_IMPL_H_
#include "ui/gfx/tbm_buffer_handle.h"
#include "webai/content/video_processor_helpers.h"
-#include <aifw_api/vision/xr_adapter.h>
#include <media_packet.h>
+#include "webai/content/dlibwrapper.h"
namespace media {
class VideoFrame;
--- /dev/null
+#include "webai/content/dlibwrapper.h"
+#include <dlfcn.h>
+#include "tizen_src/chromium_impl/webai/common/ai_logger.h"
+
+namespace content {
+vector<string> sysnamevec{"xr_adapter_create",
+ "xr_adapter_destroy",
+ "xr_adapter_init",
+ "xr_adapter_deinit",
+ "xr_adapter_set_frame_ready_cb",
+ "xr_adapter_submit_packet"};
+#define XRFW_LIBRARY "libaifw_api_vision_xr_adapter.so"
+
+std::shared_ptr<Dlibwapper> Dlibwapper::instance_ = nullptr;
+std::mutex Dlibwapper::mtx_;
+
+Dlibwapper::Dlibwapper() {
+ AI_LOG(INFO) << __func__;
+ initdone_ = Init();
+}
+Dlibwapper::~Dlibwapper() {
+ AI_LOG(INFO) << __func__;
+ bool ret = Close();
+ if (!ret) {
+ AI_LOG(ERROR) << "close failed: " << errmsg_;
+ }
+}
+bool Dlibwapper::Init() {
+ AI_LOG(INFO) << __func__;
+ bool ret = Open();
+ if (!ret) {
+ AI_LOG(ERROR) << "open failed: " << errmsg_;
+ return false;
+ }
+ ret = Loadsymboal();
+ if (!ret) {
+ AI_LOG(ERROR) << "Loadsymboal failed";
+ return false;
+ }
+ return true;
+}
+
+bool Dlibwapper::Open() {
+ AI_LOG(INFO) << __func__;
+ handle_ = dlopen(XRFW_LIBRARY, RTLD_LAZY);
+ if (handle_ != nullptr)
+ return true;
+ errmsg_ = dlerror();
+ return false;
+}
+
+bool Dlibwapper::Close() {
+ AI_LOG(INFO) << __func__;
+ if (handle_ == nullptr)
+ return true;
+
+ int err = dlclose(handle_);
+ if (err != 0) {
+ errmsg_ = dlerror();
+ AI_LOG(ERROR) << "dlclose failed " << errmsg_;
+ return false;
+ }
+ handle_ = nullptr;
+ return true;
+}
+bool Dlibwapper::Loadsymboal() {
+ AI_LOG(INFO) << __func__;
+ for (size_t k = 0; k < sysnamevec.size(); k++) {
+ sys_map_[sysnamevec[k].c_str()] = dlsym(handle_, sysnamevec[k].c_str());
+ if (sys_map_[sysnamevec[k].c_str()] == nullptr) {
+ AI_LOG(ERROR) << "Load sysmboal fail " << sysnamevec[k].c_str();
+ return false;
+ }
+ }
+ return true;
+}
+void* Dlibwapper::Getxrfwapi(const char* name) {
+ AI_LOG(INFO) << __func__;
+ int trycout = 3;
+ while (!initdone_ && trycout--) {
+ initdone_ = Init();
+ }
+ if (!initdone_) {
+ AI_LOG(ERROR) << "init Dlibwapper failed,can not call xrfwapi return";
+ return nullptr;
+ }
+ return sys_map_[name];
+}
+} // namespace content
--- /dev/null
+#ifndef WEBAI_CONTENT_DLIBWRAPPER__
+#define WEBAI_CONTENT_DLIBWRAPPER__
+#include <media_packet.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "media/base/format_utils.h"
+#include "webai/common/ai_logger.h"
+using namespace std;
+
+typedef void* xr_adapter_h;
+typedef enum {
+ AIFW_RESULT_SUCCESS = 1,
+ AIFW_RESULT_FAIL = 0,
+} aifw_result_e;
+
+typedef enum {
+ XR_ADAPTER_ERROR_NONE,
+ XR_ADAPTER_ERROR_PROCESS_FAIL
+} xr_adapter_error_type_e;
+
+typedef void (*xr_adapter_frame_ready_cb)(media_packet_h packet,
+ xr_adapter_error_type_e error,
+ void* user_data);
+typedef aifw_result_e (*xr_adapter_create)(xr_adapter_h* handle);
+typedef aifw_result_e (*xr_adapter_destroy)(xr_adapter_h handle);
+typedef aifw_result_e (*xr_adapter_init)(xr_adapter_h handle,
+ const char* config,
+ const int config_length);
+typedef aifw_result_e (*xr_adapter_deinit)(xr_adapter_h handle);
+typedef aifw_result_e (*xr_adapter_set_frame_ready_cb)(
+ xr_adapter_h handle,
+ xr_adapter_frame_ready_cb frame_ready_cb,
+ void* userdata);
+typedef aifw_result_e (*xr_adapter_submit_packet)(xr_adapter_h handle,
+ media_packet_h input_packet,
+ media_packet_h output_packet);
+
+namespace content {
+class Dlibwapper {
+ public:
+ Dlibwapper();
+ ~Dlibwapper();
+ static std::shared_ptr<Dlibwapper> Getinstance() {
+ AI_LOG(INFO) << __func__;
+ if (!instance_) {
+ lock_guard<std::mutex> guard(mtx_);
+ if (!instance_) {
+ instance_ = std::make_shared<Dlibwapper>();
+ }
+ }
+ return instance_;
+ }
+
+ void* Getxrfwapi(const char* name);
+
+ private:
+ static std::mutex mtx_;
+ static std::shared_ptr<Dlibwapper> instance_;
+
+ bool Init();
+ bool Open();
+ bool Close();
+ bool Loadsymboal();
+ Dlibwapper(const Dlibwapper&) = delete;
+ Dlibwapper& operator=(const Dlibwapper&) = delete;
+ void* handle_;
+ std::string errmsg_;
+ bool initdone_;
+ unordered_map<string, void*> sys_map_;
+};
+} // namespace content
+#endif // WEBAI_CONTENT_DLIBWRAPPER__
"//tizen_src/chromium_impl/webai/content/ai_processor_video_impl.h",
"//tizen_src/chromium_impl/webai/content/ai_video_frame_buffer.cc",
"//tizen_src/chromium_impl/webai/content/ai_video_frame_buffer.h",
+ "//tizen_src/chromium_impl/webai/content/dlibwrapper.cc",
+ "//tizen_src/chromium_impl/webai/content/dlibwrapper.h",
"//tizen_src/chromium_impl/webai/content/mojo_broker_impl.cc",
"//tizen_src/chromium_impl/webai/content/mojo_broker_impl.h",
"//tizen_src/chromium_impl/webai/content/video_processor_helpers.cc",
]
tizen_ai_content_browser_configs += [
- "//tizen_src/build:aifw-api",
"//tizen_src/build:libaifw-api",
]
projects / platform / framework / web / chromium-efl.git / commitdiff