#include "MediaTransporterException.h"
#include <algorithm>
+#include <rm_type.h>
+#include <resource_center.h>
+#include <sys/types.h>
+#include <unistd.h>
+
using namespace tizen_media_transporter;
MediaTransporterResource::MediaTransporterResource()
LOG_DEBUG("dtor: %p", this);
}
-int MediaTransporterResource::_resourceReleaseCallback(mm_resource_manager_h mgr,
- mm_resource_manager_res_h res,
- void *user_data)
+rm_cb_result MediaTransporterResource::_resourceReleaseCallback(int res, rm_callback_type event_src,
+ rm_device_request_s *info, void *cb_data)
{
- auto resourceClass = static_cast<MediaTransporterResource*>(user_data);
- RET_VAL_IF(!resourceClass, FALSE, "mtpr is NULL");
+ auto resourceClass = static_cast<MediaTransporterResource*>(cb_data);
+ RET_VAL_IF(!resourceClass, RM_CB_RESULT_ERROR, "mtpr is NULL");
+
+ LOG_WARNING("res %d, event type %d, info %p (# %d), cb_data %p", res, event_src, info, info ? info->request_num : 0, cb_data);
+
+ resourceClass->notify();
- return resourceClass->resourceReleased(res);
+ LOG_INFO("RM_CB_RESULT_OK");
+
+ return RM_CB_RESULT_OK;
}
-bool MediaTransporterResource::resourceReleased(mm_resource_manager_res_h res)
+int MediaTransporterResource::getAppid(int pid, char *name, size_t size)
{
- std::lock_guard<std::mutex> mutex(_mutex);
+ g_autofree gchar *cmdline = NULL;
+ g_autofree gchar *contents = NULL;
+ g_autofree gchar *base = NULL;
+ g_autoptr(GError) error = NULL;
- bool interrupted = false;
+ RET_VAL_IF(!name, MTPR_ERROR_INVALID_PARAMETER, "name is NULL");
+ RET_VAL_IF(size == 0, MTPR_ERROR_INVALID_PARAMETER, "size is %lu", size);
- _onReleaseCallback = true;
+ cmdline = g_strdup_printf("/proc/%d/cmdline", pid);
- for (auto& [ type, handle ] : _resources) {
- if (res == handle) {
- LOG_INFO("type[%d] resource was released by resource manager", static_cast<int>(type));
- _resources.erase(type);
- interrupted = true;
- }
+ if (!g_file_get_contents(cmdline, &contents, NULL, &error)) {
+ LOG_ERROR("error : %s", error->message);
+ return MTPR_ERROR_INVALID_OPERATION;
}
- if (interrupted)
- notify();
+ base = g_path_get_basename(contents);
- _onReleaseCallback = false;
+ if (g_strlcpy(name, base, size) >= size) {
+ LOG_ERROR("string truncated");
+ return MTPR_ERROR_INVALID_OPERATION;
+ }
- return true;
+ return MTPR_ERROR_NONE;
}
int MediaTransporterResource::create()
{
std::lock_guard<std::mutex> mutex(_mutex);
- if (mm_resource_manager_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
- _resourceReleaseCallback, this, &_mgr) != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ _rci.app_pid = (int)getpid();
+ if (getAppid(_rci.app_pid, _rci.app_id, sizeof(_rci.app_id)) != MTPR_ERROR_NONE) {
+ LOG_ERROR("__mmplayer_get_appid_by_pid is failed");
+ return MTPR_ERROR_INVALID_OPERATION;
+ }
+
+ if (rm_register((rm_resource_cb)_resourceReleaseCallback,
+ static_cast<void *>(this),
+ &(_rmHandle),
+ (_rci.app_id[0] != '\0') ? &_rci : NULL) != RM_OK) {
LOG_ERROR("failed to create resource manager");
return MTPR_ERROR_RESOURCE_FAILED;
}
- LOG_INFO("resource manager created : %p", _mgr);
+ LOG_INFO("[h %d] resource manager created ", _rmHandle);
return MTPR_ERROR_NONE;
}
-int MediaTransporterResource::acquireInternal(mm_resource_manager_res_type_e type)
+int MediaTransporterResource::acquireInternal(res_type_e type)
{
- int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
- mm_resource_manager_res_h handle;
-
- if (!_mgr)
- return MTPR_ERROR_NONE;
-
- if (_resources.find(type) != _resources.end()) {
- LOG_ERROR("type[%d] resource was already acquired", type);
+ int category_option = 0;
+ rm_rsc_category_e category_id = RM_CATEGORY_NONE;
+ rm_requests_resource_state_e state;
+ rm_category_request_s request_resources;
+
+ RET_VAL_IF(type >= RES_TYPE_MAX, MTPR_ERROR_INVALID_PARAMETER, "invalid type(%d)", type);
+
+ LOG_INFO("[h %d] app id : %s type %d", _rmHandle, _rci.app_id, type);
+ memset(&request_resources, 0x0, sizeof(rm_category_request_s));
+
+ rm_device_return_s device;
+ memset(&device, 0x0, sizeof(rm_device_return_s));
+
+ switch (type) {
+ case RES_TYPE_VIDEO_DECODER:
+ state = RM_STATE_EXCLUSIVE;
+ category_id = RM_CATEGORY_VIDEO_DECODER;
+ break;
+ case RES_TYPE_VIDEO_OVERLAY:
+ state = RM_STATE_EXCLUSIVE;
+ category_id = RM_CATEGORY_SCALER;
+ break;
+ case RES_TYPE_CAMERA:
+ state = RM_STATE_EXCLUSIVE;
+ category_id = RM_CATEGORY_CAMERA;
+ break;
+ case RES_TYPE_VIDEO_ENCODER:
+ state = RM_STATE_EXCLUSIVE;
+ category_id = RM_CATEGORY_VIDEO_ENCODER;
+ break;
+ default:
+ LOG_ERROR("category id can't set");
return MTPR_ERROR_RESOURCE_FAILED;
}
- LOG_DEBUG("mark for acquire type[%d] resource", type);
- ret = mm_resource_manager_mark_for_acquire(_mgr, type,
- MM_RESOURCE_MANAGER_RES_VOLUME_FULL, &handle);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOG_ERROR("failed to mark resource for acquire, ret[0x%x]", ret);
- return MTPR_ERROR_RESOURCE_FAILED;
- }
+ category_option = rc_get_capable_category_id(_rmHandle, _rci.app_id, category_id);
- LOG_DEBUG("commit type[%d] resource", type);
- ret = mm_resource_manager_commit(_mgr);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOG_ERROR("failed to commit of resource, ret([0x%x]", ret);
+ request_resources.request_num = 1;
+ request_resources.state[0] = state;
+ request_resources.category_id[0] = category_id;
+ request_resources.category_option[0] = category_option;
+
+ LOG_INFO("[h %d] allocate resources type[%d]", _rmHandle, type);
+
+ int ret = rm_allocate_resources(_rmHandle, &request_resources, &device);
+ if (ret != RM_OK) {
+ LOG_ERROR("failed to rm_allocate_resources, ret[0x%x]", ret);
return MTPR_ERROR_RESOURCE_FAILED;
}
- _resources[type] = handle;
+ _resources[type] = device.device_id[0];
+
+ free(device.device_node[0]);
+ free(device.omx_comp_name[0]);
return MTPR_ERROR_NONE;
}
-int MediaTransporterResource::acquire(mm_resource_manager_res_type_e type)
+int MediaTransporterResource::acquire(res_type_e type)
{
std::lock_guard<std::mutex> mutex(_mutex);
return ret;
}
+int MediaTransporterResource::release(int device_id)
+{
+ LOG_INFO("[h %d] deviceId %d", _rmHandle,device_id);
+
+ rm_device_request_s requested;
+ memset(&requested, 0x0, sizeof(rm_device_request_s));
+ requested.request_num = 1;
+ requested.device_id[0] = device_id;
+
+ int ret = rm_deallocate_resources(_rmHandle, &requested);
+ if (ret != RM_OK) {
+ LOG_ERROR("Resource deallocation request failed [%d] [handle %d]", ret, _rmHandle);
+ return MTPR_ERROR_INVALID_OPERATION;
+ }
+
+ return MTPR_ERROR_NONE;
+}
+
int MediaTransporterResource::releaseAll()
{
std::lock_guard<std::mutex> mutex(_mutex);
- int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
-
- if (!_mgr)
- return MTPR_ERROR_NONE;
+ LOG_INFO("[h %d] RELEASE ALL", _rmHandle);
- if (_onReleaseCallback) {
- LOG_INFO("__resource_release_cb is calling, so skip");
+ if (!_rmHandle) {
+ LOG_WARNING("resource handle is not register");
return MTPR_ERROR_NONE;
}
- ret = mm_resource_manager_mark_all_for_release(_mgr);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOG_ERROR("failed to mark all for release, ret[0x%x]", ret);
- return MTPR_ERROR_RESOURCE_FAILED;
- }
- ret = mm_resource_manager_commit(_mgr);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOG_ERROR("failed to commit resource, ret[0x%x]", ret);
- return MTPR_ERROR_RESOURCE_FAILED;
+ for (auto& [type, deviceId] : _resources) {
+ LOG_INFO(" => type %d device id %d", type, deviceId);
+ release(deviceId);
}
- LOG_DEBUG("all resources were released by resource manager");
+
+ LOG_INFO("[h %d] RELEASE ALL : DONE", _rmHandle);
return MTPR_ERROR_NONE;
}
-
int MediaTransporterResource::destroy()
{
std::lock_guard<std::mutex> mutex(_mutex);
- if (!_mgr)
+ LOG_INFO("[h %d] resource manager destroyed", _rmHandle);
+
+ if (!_rmHandle) {
+ LOG_WARNING("resource handle is not register");
return MTPR_ERROR_NONE;
+ }
- int ret = mm_resource_manager_destroy(_mgr);
- if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
+ int ret = rm_unregister(_rmHandle);
+ if (ret != RM_OK) {
LOG_ERROR("failed to destroy resource manager, ret[0x%x]", ret);
return MTPR_ERROR_RESOURCE_FAILED;
}
- LOG_INFO("resource manager destroyed : %p", _mgr);
- _mgr = nullptr;
-
return MTPR_ERROR_NONE;
}
-
projects / platform / core / api / mediatransporter.git / commitdiff