extern char MEDIA_IPC_PATH[][70];
-static int __media_dcm_send_request();
+static int __media_dcm_send_request(void);
-gboolean __media_dcm_check_cancel(void)
+static gboolean __media_dcm_is_canceled(void)
{
- dcmReq *req = NULL;
- req = (dcmReq *)g_queue_peek_head(g_manage_queue);
-
- if (req == NULL) {
- return FALSE;
- } else {
- if (req->isCanceled)
- return FALSE;
- else
- return TRUE;
- }
+ dcmReq *req = (dcmReq *)g_queue_peek_head(g_manage_queue);
+
+ if (!req)
+ return TRUE;
+
+ return req->isCanceled;
}
-int __media_dcm_pop_data()
+static void __media_dcm_pop_data(void)
{
int len = 0;
- if (g_manage_queue != NULL) {
- dcmReq *req = (dcmReq *)g_queue_pop_head(g_manage_queue);
- if (req != NULL) {
- GSource *source_id = g_main_context_find_source_by_id(g_main_context_get_thread_default(), req->source_id);
+ if (!g_manage_queue)
+ return;
- g_io_channel_shutdown(req->channel, TRUE, NULL);
- g_io_channel_unref(req->channel);
+ dcmReq *req = (dcmReq *)g_queue_pop_head(g_manage_queue);
+ if (req) {
+ GSource *source_id = g_main_context_find_source_by_id(g_main_context_get_thread_default(), req->source_id);
- if (source_id != NULL)
- g_source_destroy(source_id);
- else
- MSAPI_DBG_ERR("G_SOURCE_ID is NULL");
+ g_io_channel_shutdown(req->channel, TRUE, NULL);
+ g_io_channel_unref(req->channel);
- MS_SAFE_FREE(req->path);
- MS_SAFE_FREE(req->userData);
- MS_SAFE_FREE(req);
- }
+ if (source_id)
+ g_source_destroy(source_id);
+
+ MS_SAFE_FREE(req->path);
+ MS_SAFE_FREE(req->userData);
+ MS_SAFE_FREE(req);
}
len = g_queue_get_length(g_manage_queue);
if (len > 0)
__media_dcm_send_request();
-
- return MS_MEDIA_ERR_NONE;
}
-int __media_dcm_cancel_data(int request_id)
+static int __media_dcm_cancel_data(int request_id)
{
int len = 0, i = 0;
- bool flag = false;
-
- if (g_manage_queue != NULL) {
- len = g_queue_get_length(g_manage_queue);
- for (i = 0; i < len; i++) {
- dcmReq *req = NULL;
- req = (dcmReq *)g_queue_peek_nth(g_manage_queue, i);
- if (req == NULL) continue;
-
- if (req->request_id == request_id) {
- if (req->isRequested == true) {
- req->isCanceled = true;
- } else {
- g_queue_pop_nth(g_manage_queue, i);
- MS_SAFE_FREE(req->path);
- MS_SAFE_FREE(req->userData);
- MS_SAFE_FREE(req);
- }
- flag = true;
- break;
+
+ MSAPI_RETV_IF(!g_manage_queue, MS_MEDIA_ERR_INTERNAL);
+
+ len = g_queue_get_length(g_manage_queue);
+ for (i = 0; i < len; i++) {
+ dcmReq *req = (dcmReq *)g_queue_peek_nth(g_manage_queue, i);
+ if (!req)
+ continue;
+
+ if (req->request_id == request_id) {
+ if (req->isRequested) {
+ req->isCanceled = true;
+ } else {
+ g_queue_pop_nth(g_manage_queue, i);
+ MS_SAFE_FREE(req->path);
+ MS_SAFE_FREE(req->userData);
+ MS_SAFE_FREE(req);
}
+ return MS_MEDIA_ERR_NONE;
}
}
- if (flag == false)
- return MS_MEDIA_ERR_INTERNAL;
-
- return MS_MEDIA_ERR_NONE;
+ return MS_MEDIA_ERR_INTERNAL;
}
-gboolean __media_dcm_write_socket(GIOChannel *src, GIOCondition condition, gpointer data)
+static gboolean __media_dcm_write_socket(GIOChannel *src, GIOCondition condition, gpointer data)
{
dcmMsg recv_msg;
+ faceUserData *user_data = NULL;
int sock = 0;
int err = MS_MEDIA_ERR_NONE;
MSAPI_DBG("Completed. msg_type[%d], msg[%.*s], result[%d]", recv_msg.msg_type, MAX_FILEPATH_LEN, recv_msg.msg, recv_msg.result);
- if (__media_dcm_check_cancel()) {
- MSAPI_DBG_INFO("Not canceled item. call cb");
- if (data) {
- faceUserData* cb = (faceUserData*)data;
- if (cb->func != NULL) {
- /*return value, face count, user_data*/
- if (recv_msg.result < 0)
- cb->func((int)(recv_msg.result), 0, cb->user_data);
- else
- cb->func(MS_MEDIA_ERR_NONE, (int)(recv_msg.result), cb->user_data);
- }
- }
+ if (__media_dcm_is_canceled() || !data)
+ goto NEXT;
+
+ MSAPI_DBG_INFO("Call the user callback");
+ user_data = (faceUserData*)data;
+ if (user_data->func) {
+ /*return value, face count, user_data*/
+ if (recv_msg.result < 0)
+ user_data->func(recv_msg.result, 0, user_data->user_data);
+ else
+ user_data->func(MS_MEDIA_ERR_NONE, recv_msg.result, user_data->user_data);
}
+NEXT:
__media_dcm_pop_data();
-
MSAPI_DBG("Done");
return G_SOURCE_REMOVE;
}
-static int __media_dcm_send_request()
+static int __media_dcm_send_request(void)
{
int err = MS_MEDIA_ERR_NONE;
int sock = -1;
struct sockaddr_un serv_addr;
dcmReq *req_manager = NULL;
- MSAPI_DBG_FUNC();
-
err = ms_ipc_create_client_socket(MS_TIMEOUT_SEC_10, &sock);
- if (err != MS_MEDIA_ERR_NONE) {
- MSAPI_DBG_ERR("ms_ipc_create_client_socket failed");
- return err;
- }
+ MSAPI_RETVM_IF(err != MS_MEDIA_ERR_NONE, err, "ms_ipc_create_client_socket failed");
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sun_family = AF_UNIX;
g_io_channel_shutdown(channel, TRUE, NULL);
g_io_channel_unref(channel);
close(sock);
- return MS_MEDIA_ERR_SOCKET_CONN;
+ return MS_MEDIA_ERR_IPC;
}
req_manager = (dcmReq *)g_queue_peek_head(g_manage_queue);
g_io_channel_shutdown(channel, TRUE, NULL);
g_io_channel_unref(channel);
close(sock);
- return MS_MEDIA_ERR_SOCKET_SEND;
+ return MS_MEDIA_ERR_IPC;
}
MSAPI_DBG("Sending msg to dcm service (in media-server) is successful");
if (msg_type == DCM_MSG_REQUEST_CANCEL_FACE)
return __media_dcm_cancel_data(request_id);
- if (g_manage_queue == NULL)
+ if (!g_manage_queue)
g_manage_queue = g_queue_new();
dcm_req = calloc(1, sizeof(dcmReq));
- if (dcm_req == NULL) {
- MSAPI_DBG_ERR("Failed to create request element");
- return MS_MEDIA_ERR_INVALID_PARAMETER;
- }
+ MSAPI_RETV_IF(!dcm_req, MS_MEDIA_ERR_OUT_OF_MEMORY);
dcm_req->msg_type = msg_type;
dcm_req->path = g_strdup(path);
}
faceUserData *userData = (faceUserData*)malloc(sizeof(faceUserData));
- if (userData == NULL) {
- MSAPI_DBG_ERR("memory allocation failed");
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
+ MSAPI_RETV_IF(!userData, MS_MEDIA_ERR_OUT_OF_MEMORY);
userData->func = (FaceFunc)func;
userData->user_data = user_data;
/* Request for image file to the daemon "Dcm generator" */
err = __media_dcm_request_async(DCM_MSG_REQUEST_MEDIA, request_id, path, userData, uid);
- if (err != MS_MEDIA_ERR_NONE) {
- MSAPI_DBG_ERR("__media_dcm_request_async failed : %d", err);
- return err;
- }
+ MSAPI_RETVM_IF(err != MS_MEDIA_ERR_NONE, err, "__media_dcm_request_async failed : %d", err);
- return MS_MEDIA_ERR_NONE;
+ return err;
}
int dcm_request_cancel_face(const unsigned int request_id)
{
- int err = MS_MEDIA_ERR_NONE;
-
- err = __media_dcm_request_async(DCM_MSG_REQUEST_CANCEL_FACE, request_id, NULL, NULL, 0);
- if (err != MS_MEDIA_ERR_NONE) {
- MSAPI_DBG_ERR("__media_dcm_request_async failed : %d", err);
- return err;
- }
-
- return err;
+ return __media_dcm_request_async(DCM_MSG_REQUEST_CANCEL_FACE, request_id, NULL, NULL, 0);
}
static int g_dcm_service_pid = 0;
static GQueue *g_dcm_request_queue = NULL;
-static int g_dcm_queue_work = 0;
+static gboolean g_dcm_queue_work = FALSE;
typedef struct {
int client_sock;
extern char MEDIA_IPC_PATH[][70];
-gboolean _ms_dcm_agent_timer();
-gboolean _ms_dcm_check_queued_request(gpointer data);
-gboolean _ms_dcm_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port);
-
-int ms_dcm_get_server_pid()
+int ms_dcm_get_server_pid(void)
{
return g_dcm_service_pid;
}
-void ms_dcm_reset_server_status()
+void ms_dcm_reset_server_status(void)
{
g_folk_dcm_server = FALSE;
g_shutdowning_dcm_server = FALSE;
}
g_dcm_service_pid = 0;
-
- return;
}
-void _ms_dcm_create_timer(int id)
+static gboolean __ms_dcm_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port)
{
- if (id > 0)
- g_source_destroy(g_main_context_find_source_by_id(g_main_context_get_thread_default(), id));
-
- GSource *timer_src = g_timeout_source_new_seconds(MS_TIMEOUT_SEC_20);
- g_source_set_callback(timer_src, _ms_dcm_agent_timer, NULL, NULL);
- g_dcm_timer_id = g_source_attach(timer_src, g_main_context_get_thread_default());
-
-}
-
-int _media_dcm_get_error()
-{
- if (errno == EWOULDBLOCK) {
- MS_DBG_ERR("Timeout. Can't try any more");
- return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
- } else {
- MS_DBG_STRERROR("recvfrom failed");
- return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ if (ms_ipc_create_server_socket(serv_port, sock_fd) < 0) {
+ MS_DBG_ERR("_ms_dcm_create_socket failed");
+ return FALSE;
}
+
+ return TRUE;
}
-int __ms_dcm_recv_msg(int sock, dcmMsg *msg)
+static int __ms_dcm_recv_msg(int sock, dcmMsg *msg)
{
int recv_msg_len = 0;
unsigned char *buf = NULL;
- MS_DBG_FENTER();
-
MS_MALLOC(buf, sizeof(dcmMsg));
- if (buf == NULL) {
- MS_DBG_STRERROR("malloc failed");
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
+ MS_DBG_RETV_IF(!buf, MS_MEDIA_ERR_OUT_OF_MEMORY);
if ((recv_msg_len = recv(sock, buf, sizeof(dcmMsg), 0)) < 0) {
MS_DBG_STRERROR("recv failed");
MS_SAFE_FREE(buf);
- return _media_dcm_get_error();
+ return MS_MEDIA_ERR_IPC;
}
memcpy(msg, buf, sizeof(dcmMsg));
if (strlen(msg->msg) >= MAX_FILEPATH_LEN) {
MS_DBG_ERR("msg size is invlid[%zu]", strlen(msg->msg));
MS_SAFE_FREE(buf);
- return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
+ return MS_MEDIA_ERR_IPC;
}
MS_SAFE_FREE(buf);
MS_DBG("msg_type [%d]", msg->msg_type);
- MS_DBG_FLEAVE();
-
return MS_MEDIA_ERR_NONE;
}
-gboolean _ms_dcm_agent_recv_msg_from_server()
+static gboolean __ms_dcm_agent_recv_msg_from_server(void)
{
struct sockaddr_un serv_addr;
unsigned int serv_addr_len;
int sockfd = -1;
int retry = 10;
- MS_DBG_FENTER();
-
if (g_dcm_comm_sock <= 0)
- _ms_dcm_agent_prepare_tcp_socket(&g_dcm_comm_sock, MS_DCM_COMM_PORT);
+ __ms_dcm_agent_prepare_tcp_socket(&g_dcm_comm_sock, MS_DCM_COMM_PORT);
serv_addr_len = sizeof(serv_addr);
close(sockfd);
- MS_DBG_FLEAVE();
-
return TRUE;
}
-gboolean _ms_dcm_agent_execute_server()
+static gboolean __ms_dcm_agent_execute_server(void)
{
int pid;
pid = fork();
g_dcm_service_pid = pid;
- if (!_ms_dcm_agent_recv_msg_from_server()) {
+ if (!__ms_dcm_agent_recv_msg_from_server()) {
MS_DBG_ERR("_ms_dcm_agent_recv_msg_from_server is failed");
return FALSE;
}
return TRUE;
}
-gboolean _ms_dcm_agent_send_msg_to_dcm_server(dcmMsg *recv_msg, dcmMsg *res_msg)
+static gboolean __ms_dcm_agent_send_msg_to_dcm_server(dcmMsg *recv_msg, dcmMsg *res_msg)
{
int sock;
struct sockaddr_un serv_addr;
int send_str_len = strlen(recv_msg->msg);
- if (send_str_len >= MAX_FILEPATH_LEN) {
- MS_DBG_ERR("original path's length exceeds %d(max packet size)", MAX_FILEPATH_LEN);
- return FALSE;
- }
+ MS_DBG_RETVM_IF(send_str_len >= MAX_FILEPATH_LEN, FALSE, "Invalid msg");
if (ms_ipc_create_client_socket(MS_TIMEOUT_SEC_60, &sock) < 0) {
MS_DBG_ERR("ms_ipc_create_client_socket failed");
/* Connecting to the DCM service */
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
MS_DBG_STRERROR("connect failed");
- close(sock);
- return FALSE;
+ goto ERROR;
}
if (send(sock, recv_msg, sizeof(dcmMsg), 0) != sizeof(dcmMsg)) {
MS_DBG_STRERROR("send failed");
- close(sock);
- return FALSE;
+ goto ERROR;
}
MS_DBG_SLOG("Sending msg to DCM daemon is successful. msg_type [%d]", recv_msg->msg_type);
- if (__ms_dcm_recv_msg(sock, res_msg) < 0) {
- MS_DBG_ERR("__ms_dcm_recv_msg failed");
- close(sock);
- return FALSE;
- }
+ if (__ms_dcm_recv_msg(sock, res_msg) < 0)
+ goto ERROR;
MS_DBG_SLOG("recv %.*s(%d, %d) from DCM daemon is successful", MAX_FILEPATH_LEN, res_msg->msg, res_msg->msg_type, res_msg->result);
close(sock);
return TRUE;
+
+ERROR:
+ close(sock);
+
+ return FALSE;
}
-gboolean _ms_dcm_agent_timer()
+static gboolean __ms_dcm_agent_timer(gpointer data)
{
g_dcm_timer_id = 0;
MS_DBG("Timer is called.. Now killing dcm-service[%d]", g_dcm_service_pid);
/* Command Kill to DCM service */
g_shutdowning_dcm_server = TRUE;
- if (!_ms_dcm_agent_send_msg_to_dcm_server(&msg, &recv_msg)) {
- MS_DBG_ERR("_ms_dcm_agent_send_msg_to_dcm_server is failed");
+ if (!__ms_dcm_agent_send_msg_to_dcm_server(&msg, &recv_msg)) {
+ MS_DBG_ERR("__ms_dcm_agent_send_msg_to_dcm_server is failed");
g_shutdowning_dcm_server = FALSE;
}
usleep(200000);
return FALSE;
}
-gboolean _ms_dcm_request_to_server(gpointer data)
+static void __ms_dcm_create_timer(int id)
{
- int req_len = 0;
+ if (id > 0)
+ g_source_destroy(g_main_context_find_source_by_id(g_main_context_get_thread_default(), id));
+
+ GSource *timer_src = g_timeout_source_new_seconds(MS_TIMEOUT_SEC_20);
+ g_source_set_callback(timer_src, __ms_dcm_agent_timer, NULL, NULL);
+ g_dcm_timer_id = g_source_attach(timer_src, g_main_context_get_thread_default());
+
+}
+
+static gboolean __ms_dcm_request_to_server(gpointer data)
+{
+ guint req_len = 0;
req_len = g_queue_get_length(g_dcm_request_queue);
MS_DBG("Queue length : %d", req_len);
- if (req_len <= 0) {
+ if (req_len == 0) {
MS_DBG("There is no request job in the queue");
- g_dcm_queue_work = 0;
+ g_dcm_queue_work = FALSE;
return FALSE;
}
return TRUE;
}
- if (g_folk_dcm_server == FALSE) {
+ if (!g_folk_dcm_server) {
if (g_dcm_service_pid <= 0) { /* This logic is temporary */
MS_DBG_WARN("DCM service is not running.. so start it");
- if (!_ms_dcm_agent_execute_server()) {
+ if (!__ms_dcm_agent_execute_server()) {
MS_DBG_ERR("_ms_dcm_agent_execute_server is failed");
- g_dcm_queue_work = 0;
+ g_dcm_queue_work = FALSE;
return FALSE;
- } else {
- _ms_dcm_create_timer(g_dcm_timer_id);
}
+
+ __ms_dcm_create_timer(g_dcm_timer_id);
}
} else {
/* Timer is re-created*/
- _ms_dcm_create_timer(g_dcm_timer_id);
+ __ms_dcm_create_timer(g_dcm_timer_id);
}
dcmRequest *req = NULL;
req = (dcmRequest *)g_queue_pop_head(g_dcm_request_queue);
-
-// MS_DBG("Pop request %d %p", req->recv_msg->msg_type);
-
- if (req == NULL) {
- MS_DBG_ERR("Failed to get a request job from queue");
- return TRUE;
- }
+ MS_DBG_RETVM_IF(!req, TRUE, "Failed to get a request job from queue");
int client_sock = -1;
dcmMsg *recv_msg = NULL;
}
if (recv_msg) {
- if (!_ms_dcm_agent_send_msg_to_dcm_server(recv_msg, &res_msg)) {
- MS_DBG_ERR("_ms_dcm_agent_send_msg_to_dcm_server is failed");
+ if (!__ms_dcm_agent_send_msg_to_dcm_server(recv_msg, &res_msg)) {
+ MS_DBG_ERR("__ms_dcm_agent_send_msg_to_dcm_server is failed");
dcmMsg res_msg;
memset((void *)&res_msg, 0, sizeof(res_msg));
return TRUE;
}
-gboolean _ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
+static gboolean __ms_dcm_agent_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
{
struct sockaddr_un client_addr;
unsigned int client_addr_len;
int client_sock = -1;
sock = g_io_channel_unix_get_fd(src);
- if (sock < 0) {
- MS_DBG_ERR("sock fd is invalid!");
- return G_SOURCE_CONTINUE;
- }
+ MS_DBG_RETVM_IF(sock < 0, G_SOURCE_CONTINUE, "sock fd is invalid!");
client_addr_len = sizeof(client_addr);
MS_DBG("Client[%d] is accepted", client_sock);
recv_msg = calloc(1, sizeof(dcmMsg));
- if (recv_msg == NULL) {
- MS_DBG_ERR("Failed to allocate memory");
- close(client_sock);
- return G_SOURCE_CONTINUE;
+ if (!recv_msg) {
+ MS_DBG_ERR("Failed to allocate memodry");
+ goto ERROR;
}
if (__ms_dcm_recv_msg(client_sock, recv_msg) < 0) {
MS_DBG_ERR("__ms_dcm_recv_msg failed ");
- close(client_sock);
- MS_SAFE_FREE(recv_msg);
- return G_SOURCE_CONTINUE;
+ goto ERROR;
}
dcmRequest *dcm_req = NULL;
MS_MALLOC(dcm_req, sizeof(dcmRequest));
- if (dcm_req == NULL) {
+ if (!dcm_req) {
MS_DBG_ERR("Failed to create request element");
- close(client_sock);
- MS_SAFE_FREE(recv_msg);
- return G_SOURCE_CONTINUE;
+ goto ERROR;
}
dcm_req->client_sock = client_sock;
dcm_req->recv_msg = recv_msg;
- if (g_dcm_request_queue == NULL) {
- MS_DBG_WARN("queue is init");
+ if (!g_dcm_request_queue) {
+ MS_DBG_WARN("Creating queue");
g_dcm_request_queue = g_queue_new();
}
if (!g_dcm_queue_work) {
GSource *src_request = NULL;
src_request = g_idle_source_new();
- g_source_set_callback(src_request, _ms_dcm_request_to_server, NULL, NULL);
+ g_source_set_callback(src_request, __ms_dcm_request_to_server, NULL, NULL);
g_source_attach(src_request, g_main_context_get_thread_default());
- g_dcm_queue_work = 1;
+ g_dcm_queue_work = TRUE;
}
return G_SOURCE_CONTINUE;
-}
-
-gboolean _ms_dcm_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port)
-{
- int sock;
-
- if (ms_ipc_create_server_socket(serv_port, &sock) < 0) {
- MS_DBG_ERR("_ms_dcm_create_socket failed");
- return FALSE;
- }
- *sock_fd = sock;
-
- return TRUE;
+ERROR:
+ close(client_sock);
+ MS_SAFE_FREE(recv_msg);
+ return G_SOURCE_CONTINUE;
}
+
gpointer ms_dcm_agent_start_thread(gpointer data)
{
int sockfd = -1;
GIOChannel *channel = NULL;
GMainContext *context = NULL;
- MS_DBG_FENTER();
-
/* Create and bind new TCP socket */
- if (!_ms_dcm_agent_prepare_tcp_socket(&sockfd, MS_DCM_CREATOR_PORT)) {
+ if (!__ms_dcm_agent_prepare_tcp_socket(&sockfd, MS_DCM_CREATOR_PORT)) {
MS_DBG_ERR("Failed to create socket");
return NULL;
}
source = g_io_create_watch(channel, G_IO_IN);
/* Set callback to be called when socket is readable */
- g_source_set_callback(source, (GSourceFunc)_ms_dcm_agent_read_socket, NULL, NULL);
+ g_source_set_callback(source, (GSourceFunc)__ms_dcm_agent_read_socket, NULL, NULL);
g_source_attach(source, context);
MS_DBG_INFO("DCM Agent thread is running");
projects / platform / core / multimedia / media-server.git / commitdiff