package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-09-27 13:32:09 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor[osal]: Refactor C++ mpp_server to C

Browse Source 
Signed-off-by: Chandler Chen <chandler.chen@rock-chips.com>
Signed-off-by: Hongjin Li <vic.hong@rock-chips.com>
Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
Change-Id: I80ef1b56d588003d712b94d8db58540de36c9245
This commit is contained in:
Hongjin Li
2025-03-19 21:18:41 +08:00
committed by Herman Chen
parent 014bca460e
commit ed3995dc32
4 changed files with 276 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
osal/CMakeLists.txt
View File

@@ -19,7 +19,7 @@ set(MPP_ALLOCATOR
) )
set(MPP_DRIVER set(MPP_DRIVER
driver/mpp_server.cpp driver/mpp_server.c
driver/mpp_device.c driver/mpp_device.c
driver/mpp_service.c driver/mpp_service.c
driver/vcodec_service.c driver/vcodec_service.c

527
osal/driver/mpp_server.cpp → osal/driver/mpp_server.c
View File

@@ -1,17 +1,6 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/* /*
* Copyright 2021 Rockchip Electronics Co. LTD * Copyright (c) 2021 Rockchip Electronics Co., Ltd.
*
* 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.
*/ */
#define MODULE_TAG "mpp_server" #define MODULE_TAG "mpp_server"
@@ -26,12 +15,13 @@
#include "mpp_time.h" #include "mpp_time.h"
#include "osal_2str.h" #include "osal_2str.h"
#include "mpp_common.h" #include "mpp_common.h"
#include "mpp_thread.h"
#include "mpp_mem_pool.h" #include "mpp_mem_pool.h"
#include "mpp_singleton.h"
#include "mpp_server.h"
#include "mpp_device_debug.h" #include "mpp_device_debug.h"
#include "mpp_service_impl.h" #include "mpp_service_impl.h"
#include "mpp_server.h"
#include "mpp_thread.h"
#define MAX_BATCH_TASK 8 #define MAX_BATCH_TASK 8
#define MAX_SESSION_TASK 4 #define MAX_SESSION_TASK 4
@@ -61,6 +51,21 @@
mpp_assert(count >= 0); \ mpp_assert(count >= 0); \
} while (0) } while (0)
#define get_srv_server() \
({ \
MppDevServer *__tmp; \
if (!srv_server) { \
mpp_server_init(); \
} \
__tmp = srv_server; \
if (!__tmp || !__tmp->inited) { \
mpp_err("mpp server srv not init for %s at %s\n", \
__tmp ? __tmp->server_error : "invalid server", __FUNCTION__); \
__tmp = NULL; \
} \
__tmp; \
})
typedef struct MppDevTask_t MppDevTask; typedef struct MppDevTask_t MppDevTask;
typedef struct MppDevBatTask_t MppDevBatTask; typedef struct MppDevBatTask_t MppDevBatTask;
typedef struct MppDevSession_t MppDevSession; typedef struct MppDevSession_t MppDevSession;
@@ -77,15 +82,15 @@ struct MppDevTask_t {
MppDevSession *session; MppDevSession *session;
MppDevBatTask *batch; MppDevBatTask *batch;
RK_S32 slot_idx; rk_s32 slot_idx;
/* lock by server */ /* lock by server */
RK_S32 task_id; rk_s32 task_id;
/* lock by batch */ /* lock by batch */
RK_S32 batch_slot_id; rk_s32 batch_slot_id;
MppReqV1 *req; MppReqV1 *req;
RK_S32 req_cnt; rk_s32 req_cnt;
}; };
struct MppDevBatTask_t { struct MppDevBatTask_t {
@@ -96,21 +101,21 @@ struct MppDevBatTask_t {
/* link to session tasks */ /* link to session tasks */
struct list_head link_tasks; struct list_head link_tasks;
RK_U32 batch_id; rk_u32 batch_id;
MppDevBatCmd *bat_cmd; MppDevBatCmd *bat_cmd;
MppReqV1 *send_reqs; MppReqV1 *send_reqs;
MppReqV1 *wait_reqs; MppReqV1 *wait_reqs;
/* lock and clean by server */ /* lock and clean by server */
RK_S32 send_req_cnt; rk_s32 send_req_cnt;
RK_S32 wait_req_cnt; rk_s32 wait_req_cnt;
/* lock by server */ /* lock by server */
RK_S32 fill_cnt; rk_s32 fill_cnt;
RK_S32 fill_full; rk_s32 fill_full;
RK_S32 fill_timeout; rk_s32 fill_timeout;
RK_S32 poll_cnt; rk_s32 poll_cnt;
}; };
struct MppDevSession_t { struct MppDevSession_t {
@@ -126,10 +131,10 @@ struct MppDevSession_t {
MppDevMppService *ctx; MppDevMppService *ctx;
MppDevBatServ *server; MppDevBatServ *server;
RK_S32 client; rk_s32 client;
RK_S32 task_wait; rk_s32 task_wait;
RK_S32 task_done; rk_s32 task_done;
MppDevTask tasks[MAX_SESSION_TASK]; MppDevTask tasks[MAX_SESSION_TASK];
}; };
@@ -137,33 +142,50 @@ struct MppDevSession_t {
struct MppDevBatServ_t { struct MppDevBatServ_t {
MppMutex lock; MppMutex lock;
RK_S32 server_fd; rk_s32 server_fd;
RK_U32 batch_id; rk_u32 batch_id;
RK_U32 task_id; rk_u32 task_id;
/* timer for serializing process */ /* timer for serializing process */
MppTimer timer; MppTimer timer;
/* session register */ /* session register */
struct list_head session_list; struct list_head session_list;
RK_S32 session_count; rk_s32 session_count;
/* batch task queue */ /* batch task queue */
struct list_head list_batch; struct list_head list_batch;
struct list_head list_batch_free; struct list_head list_batch_free;
MppMemPool batch_pool; MppMemPool batch_pool;
RK_S32 batch_max_count; rk_s32 batch_max_count;
RK_S32 batch_task_size; rk_s32 batch_task_size;
RK_S32 batch_run; rk_s32 batch_run;
RK_S32 batch_free; rk_s32 batch_free;
RK_S32 max_task_in_batch; rk_s32 max_task_in_batch;
/* link to all pending tasks */ /* link to all pending tasks */
struct list_head pending_task; struct list_head pending_task;
RK_S32 pending_count; rk_s32 pending_count;
}; };
RK_U32 mpp_server_debug = 0; typedef struct MppDevServer_t {
const char *server_error;
const char *server_name;
rk_s32 inited;
rk_u32 enable;
MppMutex lock;
MppDevBatServ *bat_server[VPU_CLIENT_BUTT];
MppMemPool session_pool;
MppMemPool batch_pool;
rk_s32 max_task_in_batch;
const MppServiceCmdCap *cmd_cap;
} MppDevServer;
static MppDevServer *srv_server = NULL;
static rk_u32 mpp_server_debug = 0;
static void batch_reset(MppDevBatTask *batch) static void batch_reset(MppDevBatTask *batch)
{ {
@@ -182,7 +204,7 @@ MppDevBatTask *batch_add(MppDevBatServ *server)
MppDevBatTask *batch = (MppDevBatTask *)mpp_mem_pool_get(server->batch_pool); MppDevBatTask *batch = (MppDevBatTask *)mpp_mem_pool_get(server->batch_pool);
mpp_assert(batch); mpp_assert(batch);
if (NULL == batch) if (!batch)
return batch; return batch;
INIT_LIST_HEAD(&batch->link_server); INIT_LIST_HEAD(&batch->link_server);
@@ -217,7 +239,7 @@ void batch_del(MppDevBatServ *server, MppDevBatTask *batch)
void batch_send(MppDevBatServ *server, MppDevBatTask *batch) void batch_send(MppDevBatServ *server, MppDevBatTask *batch)
{ {
RK_S32 ret = 0; rk_s32 ret = 0;
mpp_assert(batch->send_req_cnt); mpp_assert(batch->send_req_cnt);
@@ -241,20 +263,20 @@ void process_task(void *p)
{ {
MppDevBatServ *server = (MppDevBatServ *)p; MppDevBatServ *server = (MppDevBatServ *)p;
MppMutex *lock = &server->lock; MppMutex *lock = &server->lock;
RK_S32 ret = MPP_OK; rk_s32 ret = rk_ok;
MppDevTask *task; MppDevTask *task;
MppDevBatTask *batch; MppDevBatTask *batch;
MppDevSession *session = NULL; MppDevSession *session = NULL;
MppDevBatCmd *bat_cmd; MppDevBatCmd *bat_cmd;
MppReqV1 *req = NULL; MppReqV1 *req = NULL;
RK_S32 pending = 0; rk_s32 pending = 0;
mpp_serv_dbg_flow("process task start\n"); mpp_serv_dbg_flow("process task start\n");
/* 1. try poll and get finished task */ /* 1. try poll and get finished task */
do { do {
batch = list_first_entry_or_null(&server->list_batch, MppDevBatTask, link_server); batch = list_first_entry_or_null(&server->list_batch, MppDevBatTask, link_server);
if (NULL == batch) if (!batch)
break; break;
mpp_assert(batch->wait_req_cnt); mpp_assert(batch->wait_req_cnt);
@@ -263,7 +285,7 @@ void process_task(void *p)
MppDevTask *n; MppDevTask *n;
list_for_each_entry_safe(task, n, &batch->link_tasks, MppDevTask, link_batch) { list_for_each_entry_safe(task, n, &batch->link_tasks, MppDevTask, link_batch) {
RK_S32 batch_slot_id = task->batch_slot_id; rk_s32 batch_slot_id = task->batch_slot_id;
MppDevBatCmd *cmd = batch->bat_cmd + batch_slot_id; MppDevBatCmd *cmd = batch->bat_cmd + batch_slot_id;
mpp_assert(batch_slot_id < server->max_task_in_batch); mpp_assert(batch_slot_id < server->max_task_in_batch);
@@ -354,7 +376,7 @@ try_proc_pending_task:
batch = list_first_entry_or_null(&server->list_batch_free, MppDevBatTask, link_server); batch = list_first_entry_or_null(&server->list_batch_free, MppDevBatTask, link_server);
mpp_assert(batch); mpp_assert(batch);
if (NULL == batch) { if (!batch) {
mpp_log_f("batch run %d free %d\n", server->batch_run, server->batch_free); mpp_log_f("batch run %d free %d\n", server->batch_run, server->batch_free);
return; return;
} }
@@ -417,7 +439,7 @@ try_proc_pending_task:
req->data_ptr = REQ_DATA_PTR(bat_cmd); req->data_ptr = REQ_DATA_PTR(bat_cmd);
{ {
RK_S32 i; rk_s32 i;
for (i = 0; i < task->req_cnt; i++) for (i = 0; i < task->req_cnt; i++)
batch->send_reqs[batch->send_req_cnt++] = task->req[i]; batch->send_reqs[batch->send_req_cnt++] = task->req[i];
@@ -461,14 +483,14 @@ static void *mpp_server_thread(void *ctx)
return NULL; return NULL;
} }
MPP_RET send_task(MppDevMppService *ctx) rk_s32 send_task(MppDevMppService *ctx)
{ {
MppDevTask *task = NULL; MppDevTask *task = NULL;
MppDevSession *session = (MppDevSession *)ctx->serv_ctx; MppDevSession *session = (MppDevSession *)ctx->serv_ctx;
if (NULL == session || NULL == session->server) { if (!session || !session->server) {
mpp_err_f("invalid ctx %p session %p send task\n", ctx, session); mpp_err_f("invalid ctx %p session %p send task\n", ctx, session);
return MPP_NOK; return rk_nok;
} }
MppDevBatServ *server = session->server; MppDevBatServ *server = session->server;
@@ -499,19 +521,19 @@ MPP_RET send_task(MppDevMppService *ctx)
mpp_timer_set_enable(server->timer, 1); mpp_timer_set_enable(server->timer, 1);
mpp_mutex_unlock(&server->lock); mpp_mutex_unlock(&server->lock);
return MPP_OK; return rk_ok;
} }
MPP_RET wait_task(MppDevMppService *ctx, RK_S64 timeout) rk_s32 wait_task(MppDevMppService *ctx, rk_s64 timeout)
{ {
RK_S32 ret = MPP_OK; rk_s32 ret = rk_ok;
MppDevTask *task = NULL; MppDevTask *task = NULL;
MppDevSession *session = (MppDevSession *)ctx->serv_ctx; MppDevSession *session = (MppDevSession *)ctx->serv_ctx;
(void) timeout; (void) timeout;
if (NULL == session) { if (!session) {
mpp_err_f("invalid ctx %p send task\n", ctx); mpp_err_f("invalid ctx %p send task\n", ctx);
return MPP_NOK; return rk_nok;
} }
task = list_first_entry_or_null(&session->list_wait, MppDevTask, link_session); task = list_first_entry_or_null(&session->list_wait, MppDevTask, link_session);
@@ -530,170 +552,40 @@ MPP_RET wait_task(MppDevMppService *ctx, RK_S64 timeout)
list_del_init(&task->link_session); list_del_init(&task->link_session);
list_add_tail(&task->link_session, &session->list_done); list_add_tail(&task->link_session, &session->list_done);
mpp_assert(session->task_wait == session->task_done); return ret;
return (MPP_RET)ret;
} }
class MppDevServer static MppDevBatServ *bat_server_get(MppDevServer *srv, MppClientType client_type)
{
private:
// avoid any unwanted function
MppDevServer();
~MppDevServer();
MppDevServer(const MppDevServer &);
MppDevServer &operator=(const MppDevServer &);
void clear();
const char *mServerError;
const char *mServerName;
RK_S32 mInited;
RK_U32 mEnable;
MppDevBatServ *mBatServer[VPU_CLIENT_BUTT];
MppMemPool mSessionPool;
MppMemPool mBatchPool;
RK_S32 mMaxTaskInBatch;
const MppServiceCmdCap *mCmdCap;
public:
static MppDevServer *get_inst() {
static MppDevServer inst;
return &inst;
}
MppMutex lock;
MppDevBatServ *bat_server_get(MppClientType client_type);
MPP_RET bat_server_put(MppClientType client_type);
MPP_RET attach(MppDevMppService *ctx);
MPP_RET detach(MppDevMppService *ctx);
MPP_RET check_status(void);
};
MppDevServer::MppDevServer() :
mServerError(NULL),
mServerName(NULL),
mInited(0),
mEnable(1),
mSessionPool(NULL),
mBatchPool(NULL),
mMaxTaskInBatch(0),
mCmdCap(NULL)
{
RK_S32 batch_task_size = 0;
mpp_env_get_u32("mpp_server_debug", &mpp_server_debug, 0);
mpp_env_get_u32("mpp_server_enable", &mEnable, 1);
mpp_env_get_u32("mpp_server_batch_task", (RK_U32 *)&mMaxTaskInBatch,
MAX_BATCH_TASK);
mpp_assert(mMaxTaskInBatch >= 1 && mMaxTaskInBatch <= 32);
batch_task_size = sizeof(MppDevBatTask) + mMaxTaskInBatch *
(sizeof(MppReqV1) * (MAX_REQ_SEND_CNT + MAX_REQ_WAIT_CNT) +
sizeof(MppDevBatCmd));
mCmdCap = mpp_get_mpp_service_cmd_cap();
if (MPP_OK != mpp_service_check_cmd_valid(MPP_CMD_SET_SESSION_FD, mCmdCap)) {
mServerError = "mpp_service cmd not support";
return;
}
do {
mServerName = mpp_get_mpp_service_name();
if (NULL == mServerName) {
mServerError = "get service device failed";
break;
}
mSessionPool = mpp_mem_pool_init(sizeof(MppDevSession));
if (NULL == mSessionPool) {
mServerError = "create session pool failed";
break;
}
mBatchPool = mpp_mem_pool_init(batch_task_size);
if (NULL == mBatchPool) {
mServerError = "create batch tack pool failed";
break;
}
mInited = 1;
} while (0);
if (!mInited) {
clear();
return;
}
mpp_mutex_init(&lock);
memset(mBatServer, 0, sizeof(mBatServer));
}
MppDevServer::~MppDevServer()
{
RK_S32 i;
for (i = 0; i < VPU_CLIENT_BUTT; i++)
bat_server_put((MppClientType)i);
mpp_mutex_destroy(&lock);
clear();
}
void MppDevServer::clear()
{
if (mSessionPool) {
mpp_mem_pool_deinit(mSessionPool);
mSessionPool = NULL;
}
if (mBatchPool) {
mpp_mem_pool_deinit(mBatchPool);
mBatchPool = NULL;
}
mInited = 0;
mEnable = 0;
}
MppDevBatServ *MppDevServer::bat_server_get(MppClientType client_type)
{ {
MppDevBatServ *server = NULL; MppDevBatServ *server = NULL;
char timer_name[32];
mpp_mutex_lock(&lock); mpp_mutex_lock(&srv->lock);
server = mBatServer[client_type]; server = srv->bat_server[client_type];
if (server) { if (server) {
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return server; return server;
} }
server = mpp_calloc(MppDevBatServ, 1); server = mpp_calloc(MppDevBatServ, 1);
if (NULL == server) { if (!server) {
mpp_err("mpp server failed to get bat server\n"); mpp_err("mpp server failed to get bat server\n");
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return NULL; return NULL;
} }
server->server_fd = open(mServerName, O_RDWR | O_CLOEXEC); server->server_fd = open(srv->server_name, O_RDWR | O_CLOEXEC);
if (server->server_fd < 0) { if (server->server_fd < 0) {
mpp_err("mpp server get bat server failed to open device\n"); mpp_err("mpp server get bat server failed to open device\n");
goto failed; goto failed;
} }
char timer_name[32];
snprintf(timer_name, sizeof(timer_name) - 1, "%s_bat", snprintf(timer_name, sizeof(timer_name) - 1, "%s_bat",
strof_client_type(client_type)); strof_client_type(client_type));
server->timer = mpp_timer_get(timer_name); server->timer = mpp_timer_get(timer_name);
if (NULL == server->timer) { if (!server->timer) {
mpp_err("mpp server get bat server failed to create timer\n"); mpp_err("mpp server get bat server failed to create timer\n");
goto failed; goto failed;
} }
@@ -709,11 +601,12 @@ MppDevBatServ *MppDevServer::bat_server_get(MppClientType client_type)
INIT_LIST_HEAD(&server->list_batch_free); INIT_LIST_HEAD(&server->list_batch_free);
INIT_LIST_HEAD(&server->pending_task); INIT_LIST_HEAD(&server->pending_task);
server->batch_pool = mBatchPool; server->batch_pool = srv->batch_pool;
server->max_task_in_batch = mMaxTaskInBatch; server->max_task_in_batch = srv->max_task_in_batch;
srv->bat_server[client_type] = server;
mpp_mutex_unlock(&srv->lock);
mBatServer[client_type] = server;
mpp_mutex_unlock(&lock);
return server; return server;
failed: failed:
@@ -730,24 +623,25 @@ failed:
mpp_mutex_destroy(&server->lock); mpp_mutex_destroy(&server->lock);
} }
MPP_FREE(server); MPP_FREE(server);
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return server;
return NULL;
} }
MPP_RET MppDevServer::bat_server_put(MppClientType client_type) static rk_s32 bat_server_put(MppDevServer *srv, MppClientType client_type)
{ {
MppDevBatTask *batch, *n;
MppDevBatServ *server = NULL; MppDevBatServ *server = NULL;
MppDevBatTask *batch, *n;
mpp_mutex_lock(&lock); mpp_mutex_lock(&srv->lock);
if (NULL == mBatServer[client_type]) { if (!srv->bat_server[client_type]) {
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return MPP_OK; return rk_ok;
} }
server = mBatServer[client_type]; server = srv->bat_server[client_type];
mBatServer[client_type] = NULL; srv->bat_server[client_type] = NULL;
mpp_assert(server->batch_run == 0); mpp_assert(server->batch_run == 0);
mpp_assert(list_empty(&server->list_batch)); mpp_assert(list_empty(&server->list_batch));
@@ -773,41 +667,38 @@ MPP_RET MppDevServer::bat_server_put(MppClientType client_type)
} }
mpp_mutex_destroy(&server->lock); mpp_mutex_destroy(&server->lock);
MPP_FREE(server); MPP_FREE(server);
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return MPP_OK; return rk_ok;
} }
MPP_RET MppDevServer::attach(MppDevMppService *ctx) static rk_s32 server_attach(MppDevServer *srv, MppDevMppService *ctx)
{ {
RK_U32 i;
if (!mInited) {
mpp_err("mpp server failed for %s\n", mServerError);
return MPP_NOK;
}
MppClientType client_type = (MppClientType)ctx->client_type; MppClientType client_type = (MppClientType)ctx->client_type;
MppDevBatServ *server;
MppDevSession *session;
rk_u32 i;
if (client_type < 0 || client_type >= VPU_CLIENT_BUTT) { if (client_type < 0 || client_type >= VPU_CLIENT_BUTT) {
mpp_err("mpp server attach failed with invalid client type %d\n", client_type); mpp_err("mpp server attach failed with invalid client type %d\n", client_type);
return MPP_NOK; return rk_nok;
} }
/* if client type server is not created create it first */ /* if client type server is not created create it first */
MppDevBatServ *server = bat_server_get(client_type); server = bat_server_get(srv, client_type);
if (NULL == server) { if (!server) {
mpp_err("mpp server get bat server with client type %d failed\n", client_type); mpp_err("mpp server get bat server with client type %d failed\n", client_type);
return MPP_NOK; return rk_nok;
} }
mpp_mutex_lock(&lock); mpp_mutex_lock(&srv->lock);
if (ctx->serv_ctx) { if (ctx->serv_ctx) {
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return MPP_OK; return rk_ok;
} }
MppDevSession *session = (MppDevSession *)mpp_mem_pool_get(mSessionPool); session = (MppDevSession *)mpp_mem_pool_get(srv->session_pool);
INIT_LIST_HEAD(&session->list_server); INIT_LIST_HEAD(&session->list_server);
INIT_LIST_HEAD(&session->list_wait); INIT_LIST_HEAD(&session->list_wait);
INIT_LIST_HEAD(&session->list_done); INIT_LIST_HEAD(&session->list_done);
@@ -836,7 +727,7 @@ MPP_RET MppDevServer::attach(MppDevMppService *ctx)
list_add_tail(&session->list_server, &server->session_list); list_add_tail(&session->list_server, &server->session_list);
ctx->serv_ctx = session; ctx->serv_ctx = session;
if (mEnable) { if (srv->enable) {
ctx->batch_io = 1; ctx->batch_io = 1;
ctx->server = server->server_fd; ctx->server = server->server_fd;
} else { } else {
@@ -846,29 +737,23 @@ MPP_RET MppDevServer::attach(MppDevMppService *ctx)
server->batch_max_count++; server->batch_max_count++;
server->session_count++; server->session_count++;
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return MPP_OK; return rk_ok;
} }
MPP_RET MppDevServer::detach(MppDevMppService *ctx) static rk_s32 server_detach(MppDevServer *srv, MppDevMppService *ctx)
{ {
if (!mInited) {
mpp_err("mpp server failed for %s\n", mServerError);
return MPP_NOK;
}
MppClientType client_type = (MppClientType)ctx->client_type; MppClientType client_type = (MppClientType)ctx->client_type;
MppDevBatServ *server = bat_server_get(srv, client_type);
MppDevBatServ *server = bat_server_get(client_type);
MppDevSession *session = (MppDevSession *)ctx->serv_ctx; MppDevSession *session = (MppDevSession *)ctx->serv_ctx;
mpp_assert(server); mpp_assert(server);
mpp_mutex_lock(&lock); mpp_mutex_lock(&srv->lock);
if (NULL == ctx->serv_ctx) { if (!ctx->serv_ctx) {
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return MPP_OK; return rk_ok;
} }
ctx->server = ctx->client; ctx->server = ctx->client;
@@ -885,52 +770,172 @@ MPP_RET MppDevServer::detach(MppDevMppService *ctx)
mpp_mutex_cond_destroy(&session->cond_lock); mpp_mutex_cond_destroy(&session->cond_lock);
mpp_mem_pool_put(mSessionPool, session); mpp_mem_pool_put(srv->session_pool, session);
server->batch_max_count++; server->batch_max_count++;
server->session_count++; server->session_count++;
mpp_mutex_unlock(&lock); mpp_mutex_unlock(&srv->lock);
return MPP_OK;
return rk_ok;
} }
MPP_RET MppDevServer::check_status(void) static void server_clear(MppDevServer *srv)
{ {
if (!mInited) { if (srv) {
mpp_err("mpp server failed for %s\n", mServerError); if (srv->session_pool) {
return MPP_NOK; mpp_mem_pool_deinit(srv->session_pool);
srv->session_pool = NULL;
} }
return MPP_OK; if (srv->batch_pool) {
mpp_mem_pool_deinit(srv->batch_pool);
srv->batch_pool = NULL;
} }
MPP_RET mpp_server_attach(MppDev ctx) srv->inited = 0;
srv->enable = 0;
mpp_free(srv);
}
}
static void mpp_server_init()
{ {
MppDevServer *srv = srv_server;
rk_s32 batch_task_size = 0;
if (srv)
return;
srv = mpp_calloc(MppDevServer, 1);
if (!srv) {
mpp_err_f("failed to allocate mpp_server service\n");
return;
}
srv_server = srv;
srv->server_error = NULL;
srv->server_name = NULL;
srv->inited = 0;
srv->enable = 1;
srv->session_pool = NULL;
srv->batch_pool = NULL;
srv->max_task_in_batch = 0;
srv->cmd_cap = NULL;
mpp_env_get_u32("mpp_server_debug", &mpp_server_debug, 0);
mpp_env_get_u32("mpp_server_enable", &srv->enable, 1);
mpp_env_get_u32("mpp_server_batch_task", (rk_u32 *)&srv->max_task_in_batch,
MAX_BATCH_TASK);
mpp_assert(srv->max_task_in_batch >= 1 && srv->max_task_in_batch <= 32);
batch_task_size = sizeof(MppDevBatTask) + srv->max_task_in_batch *
(sizeof(MppReqV1) * (MAX_REQ_SEND_CNT + MAX_REQ_WAIT_CNT) +
sizeof(MppDevBatCmd));
srv->cmd_cap = mpp_get_mpp_service_cmd_cap();
if (rk_ok != mpp_service_check_cmd_valid(MPP_CMD_SET_SESSION_FD, srv->cmd_cap)) {
srv->server_error = "mpp_service cmd not support";
return;
}
mpp_mutex_init(&srv->lock);
memset(srv->bat_server, 0, sizeof(srv->bat_server));
do {
srv->server_name = mpp_get_mpp_service_name();
if (!srv->server_name) {
srv->server_error = "get service device failed";
break;
}
srv->session_pool = mpp_mem_pool_init(sizeof(MppDevSession));
if (!srv->session_pool) {
srv->server_error = "create session pool failed";
break;
}
srv->batch_pool = mpp_mem_pool_init(batch_task_size);
if (!srv->batch_pool) {
srv->server_error = "create batch tack pool failed";
break;
}
srv->inited = 1;
} while (0);
if (!srv->inited) {
server_clear(srv);
srv_server = NULL;
}
}
static void mpp_server_deinit()
{
MppDevServer *srv = srv_server;
srv_server = NULL;
if (srv) {
rk_s32 i;
for (i = 0; i < VPU_CLIENT_BUTT; i++)
bat_server_put(srv, (MppClientType)i);
mpp_mutex_destroy(&srv->lock);
server_clear(srv);
}
}
rk_s32 mpp_server_attach(MppDev ctx)
{
MppDevServer *srv = get_srv_server();
rk_s32 ret = rk_nok;
if (srv && ctx) {
MppDevMppService *dev = (MppDevMppService *)ctx; MppDevMppService *dev = (MppDevMppService *)ctx;
return MppDevServer::get_inst()->attach(dev); ret = server_attach(srv, dev);
} }
MPP_RET mpp_server_detach(MppDev ctx) return ret;
}
rk_s32 mpp_server_detach(MppDev ctx)
{ {
MppDevServer *srv = get_srv_server();
rk_s32 ret = rk_nok;
if (srv && ctx) {
MppDevMppService *dev = (MppDevMppService *)ctx; MppDevMppService *dev = (MppDevMppService *)ctx;
return MppDevServer::get_inst()->detach(dev); ret = server_detach(srv, dev);
} }
MPP_RET mpp_server_send_task(MppDev ctx) return ret;
}
rk_s32 mpp_server_send_task(MppDev ctx)
{ {
MPP_RET ret = MppDevServer::get_inst()->check_status(); MppDevServer *srv = get_srv_server();
if (!ret) rk_s32 ret = rk_nok;
if (srv && ctx)
ret = send_task((MppDevMppService *)ctx); ret = send_task((MppDevMppService *)ctx);
return ret; return ret;
} }
MPP_RET mpp_server_wait_task(MppDev ctx, RK_S64 timeout) rk_s32 mpp_server_wait_task(MppDev ctx, rk_s64 timeout)
{ {
MPP_RET ret = MppDevServer::get_inst()->check_status(); MppDevServer *srv = get_srv_server();
if (!ret) rk_s32 ret = rk_nok;
if (srv && ctx)
ret = wait_task((MppDevMppService *)ctx, timeout); ret = wait_task((MppDevMppService *)ctx, timeout);
return ret; return ret;
} }
MPP_SINGLETON(MPP_SGLN_SERVER, mpp_server, mpp_server_init, mpp_server_deinit)

23
osal/inc/mpp_server.h
View File

@@ -1,17 +1,6 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/* /*
* Copyright 2021 Rockchip Electronics Co. LTD * Copyright (c) 2021 Rockchip Electronics Co., Ltd.
*
* 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.
*/ */
#ifndef __MPP_SERVER_H__ #ifndef __MPP_SERVER_H__
@@ -23,11 +12,11 @@
extern "C" { extern "C" {
#endif #endif
MPP_RET mpp_server_attach(MppDev ctx); rk_s32 mpp_server_attach(MppDev ctx);
MPP_RET mpp_server_detach(MppDev ctx); rk_s32 mpp_server_detach(MppDev ctx);
MPP_RET mpp_server_send_task(MppDev ctx); rk_s32 mpp_server_send_task(MppDev ctx);
MPP_RET mpp_server_wait_task(MppDev ctx, RK_S64 timeout); rk_s32 mpp_server_wait_task(MppDev ctx, RK_S64 timeout);
#ifdef __cplusplus #ifdef __cplusplus
} }

1
osal/inc/mpp_singleton.h
View File

@@ -19,6 +19,7 @@ typedef enum MppSingletonId_e {
/* hardware platform */ /* hardware platform */
MPP_SGLN_SOC, MPP_SGLN_SOC,
MPP_SGLN_PLATFORM, MPP_SGLN_PLATFORM,
MPP_SGLN_SERVER,
/* software platform */ /* software platform */
MPP_SGLN_RUNTIME, MPP_SGLN_RUNTIME,
/* base module */ /* base module */