#define DCM_IPC_MSG_MAX_SIZE 4096
#define DCM_DB_QUERY_MAX_SIZE 4096
-typedef enum {
- DCM_SUCCESS,
- DCM_ERROR_INVALID_PARAMETER,
- DCM_ERROR_NETWORK,
- DCM_ERROR_DB_OPERATION,
- DCM_ERROR_DB_NO_RESULT,
- DCM_ERROR_FILE_NOT_EXIST,
- DCM_ERROR_OUT_OF_MEMORY,
- DCM_ERROR_IMAGE_ALREADY_SCANNED,
- DCM_ERROR_CREATE_THREAD_FAILED,
- DCM_ERROR_IMAGE_UTIL_FAILED,
- DCM_ERROR_ASYNC_QUEUE_FAILED,
- DCM_ERROR_IPC,
- DCM_ERROR_IPC_INVALID_MSG,
- DCM_ERROR_INVALID_IMAGE_SIZE,
- DCM_ERROR_CODEC_DECODE_FAILED,
- DCM_ERROR_CODEC_ENCODE_FAILED,
- DCM_ERROR_UNSUPPORTED_IMAGE_TYPE,
- DCM_ERROR_FACE_ENGINE_FAILED,
- DCM_ERROR_EXIF_FAILED,
- DCM_ERROR_UUID_GENERATE_FAILED,
- DCM_ERROR_DUPLICATED_DATA,
-} DcmErrorType;
-
typedef enum {
DCM_IPC_PORT_SCAN_RECV = 0,
DCM_IPC_PORT_DCM_RECV,
#include <dcm_image_debug_utils.h>
#include <dcm_image_codec.h>
#include <DcmTypes.h>
+#include <media-util.h>
#define MIME_TYPE_JPEG "image/jpeg"
#define MIME_TYPE_PNG "image/png"
unsigned int rotated_buffer_size = 0;
int rotated_width = 0, rotated_height = 0;
- DCM_CHECK_VAL(source, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(source, MS_MEDIA_ERR_INVALID_PARAMETER);
if (format == DCM_IMAGE_FORMAT_I420) {
colorspace = IMAGE_UTIL_COLORSPACE_I420;
} else if (format == DCM_IMAGE_FORMAT_RGBA) {
colorspace = IMAGE_UTIL_COLORSPACE_RGBA8888;
} else {
- return DCM_ERROR_UNSUPPORTED_IMAGE_TYPE;
+ return MS_MEDIA_ERR_UNSUPPORTED_CONTENT;
}
/* Get rotate angle enum */
ret = image_util_calculate_buffer_size(rotated_width, rotated_height, colorspace, &rotated_buffer_size);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Failed to calculate buffer size! err: %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* Allocate rotated buffer */
if (rotated_buffer_size <= 0) {
dcm_error("Invalid rotated buffer size!");
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
dcm_debug("rotate buffer size: %u", rotated_buffer_size);
rotated_buffer = (unsigned char *) g_malloc0(rotated_buffer_size);
if (rotated_buffer == NULL) {
dcm_error("rotated_buffer is NULL!");
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
*size = rotated_buffer_size;
- try {
- /* Rotate input buffer */
- ret = image_util_rotate(rotated_buffer, &rotated_width, &rotated_height, rotate, source,
- *buff_width, *buff_height, colorspace);
+ /* Rotate input buffer */
+ ret = image_util_rotate(rotated_buffer, &rotated_width, &rotated_height, rotate, source,
+ *buff_width, *buff_height, colorspace);
- if (ret != IMAGE_UTIL_ERROR_NONE || rotated_buffer == NULL) {
- dcm_error("Failed to rotate image buffer! err: %d", ret);
- throw DCM_ERROR_IMAGE_UTIL_FAILED;
- }
-
- /* Decoded buffer size is set to rotated buffer size to match buffer */
- dcm_debug("After rotation: [width: %d] [height: %d]", rotated_width, rotated_height);
- *buff_width = rotated_width;
- *buff_height = rotated_height;
-
- /* Allocated data should be freed when scanning is finished for this rotated image */
- *image_buffer = rotated_buffer;
- dcm_warn("rotated decode buffer: %p", *image_buffer);
-
- } catch (DcmErrorType &e) {
+ if (ret != IMAGE_UTIL_ERROR_NONE || rotated_buffer == NULL) {
+ dcm_error("Failed to rotate image buffer! err: %d", ret);
DCM_SAFE_FREE(rotated_buffer);
- dcm_error("image util rotate error!");
- return e;
+ return MS_MEDIA_ERR_INTERNAL;
}
- return DCM_SUCCESS;
+ /* Decoded buffer size is set to rotated buffer size to match buffer */
+ dcm_debug("After rotation: [width: %d] [height: %d]", rotated_width, rotated_height);
+ *buff_width = rotated_width;
+ *buff_height = rotated_height;
+
+ /* Allocated data should be freed when scanning is finished for this rotated image */
+ *image_buffer = rotated_buffer;
+ dcm_warn("rotated decode buffer: %p", *image_buffer);
+
+ return MS_MEDIA_ERR_NONE;
}
int _dcm_rotate_rgb(unsigned char *source, const unsigned long long *size, int format, unsigned int *ori_width, unsigned int *ori_height)
dpp = 3;
} else {
dcm_error("Invalid parameter");
- return DCM_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
temp_buf = (unsigned char*)malloc(_size);
if (temp_buf == NULL) {
dcm_error("Failed to allocate memory");
- return DCM_ERROR_OUT_OF_MEMORY;
+ return MS_MEDIA_ERR_OUT_OF_MEMORY;
}
/* initialize */
memset(temp_buf, 0x00, _size);
*ori_width = height;
*ori_height = width;
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int dcm_decode_image(const char *file_path, const dcm_image_format_e format,
dcm_debug_fenter();
- DCM_CHECK_VAL(file_path, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(file_path, MS_MEDIA_ERR_INVALID_PARAMETER);
ret = image_util_decode_create(&handle);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Error image_util_decode_create ret : %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
ret = image_util_decode_set_input_path(handle, file_path);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Error image_util_decode_set_input_path ret : %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
if (strcmp(mimne_type, MIME_TYPE_JPEG) == 0) {
colorspace = IMAGE_UTIL_COLORSPACE_RGBA8888;
mm_format = MM_UTIL_IMG_FMT_RGBA8888;
} else {
- return DCM_ERROR_UNSUPPORTED_IMAGE_TYPE;
+ return MS_MEDIA_ERR_UNSUPPORTED_CONTENT;
}
ret = image_util_decode_set_colorspace(handle, colorspace);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Error image_util_decode_set_colorspace ret : %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
}
ret = image_util_decode_set_output_buffer(handle, &decode_buffer);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Error image_util_decode_set_output_buffer ret : %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
ret = image_util_decode_run(handle, (unsigned long *)&decode_width, (unsigned long *)&decode_height, size);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Error image_util_decode_run ret : %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
ret = image_util_decode_destroy(handle);
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("Error image_util_decode_destroy ret : %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* Resize the big size image to enhance performance for big size image */
if ((decode_width != *buff_width) || (decode_height != *buff_height)) {
ret = image_util_calculate_buffer_size(*buff_width, *buff_height, colorspace, &buffer_size);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to calculate image buffer size! err: %d", ret);
- return DCM_ERROR_CODEC_DECODE_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
*size = buffer_size;
resize_buffer = (unsigned char *)malloc(sizeof(unsigned char) * (buffer_size));
} else {
ret = _dcm_rotate_image(resize_buffer, format, orientation, image_buffer, size, buff_width, buff_height);
}
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to rotate image buffer! err: %d", ret);
- return DCM_ERROR_CODEC_DECODE_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
}
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmColorUtils::runColorExtractProcess(DcmScanItem *scan_item, DcmImageInfo *image_info)
{
- DCM_CHECK_VAL(scan_item, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(image_info, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(image_info->pixel, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(image_info, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(image_info->pixel, MS_MEDIA_ERR_INVALID_PARAMETER);
dcm_debug_fenter();
#if 0
ret = image_util_extract_color_from_memory(image_info->pixel, image_info->buffer_width, image_info->buffer_height, &(colorItem.rgb_r), &(colorItem.rgb_g), &(colorItem.rgb_b));
if (ret != IMAGE_UTIL_ERROR_NONE) {
dcm_error("image_util_extract_color_from_memory err= %d", ret);
- return DCM_ERROR_IMAGE_UTIL_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
dcm_debug("image_util_extract_color_from_memory result r:%02x, g:%02x, b:%02x", colorItem.rgb_r, colorItem.rgb_g, colorItem.rgb_b);
colorItem.media_uuid = strdup(scan_item->media_uuid);
colorItem.storage_uuid = strdup(scan_item->storage_uuid);
ret = dcmDbUtils->_dcm_svc_db_update_color_to_db(colorItem);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to update color item into db! err: %d", ret);
- return DCM_ERROR_DB_OPERATION;
+ return MS_MEDIA_ERR_DB_INTERNAL;
}
#endif
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
static int DcmDbUtilsInternal::__dcm_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3_stmt** stmt)
{
- int err = -1;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug("[SQL query] : %s", sql_str);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
- err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
+ ret = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
sqlite3_free((char *)sql_str);
- if (err != SQLITE_OK) {
- dcm_error ("prepare error %d[%s]", err, sqlite3_errmsg(handle));
- if (err == SQLITE_CORRUPT) {
+ if (ret != SQLITE_OK) {
+ dcm_error ("prepare error %d[%s]", ret, sqlite3_errmsg(handle));
+ if (ret == SQLITE_CORRUPT) {
return MS_MEDIA_ERR_DB_CORRUPT;
- } else if (err == SQLITE_PERM) {
+ } else if (ret == SQLITE_PERM) {
return MS_MEDIA_ERR_DB_PERMISSION;
}
return MS_MEDIA_ERR_DB_INTERNAL;
}
- err = sqlite3_step(*stmt);
- if (err != SQLITE_ROW) {
+ ret = sqlite3_step(*stmt);
+ if (ret != SQLITE_ROW) {
dcm_error("[No-Error] Item not found. end of row [%s]", sqlite3_errmsg(handle));
DCM_SQLITE3_FINALIZE(*stmt);
return MS_MEDIA_ERR_DB_NO_RECORD;
static int DcmDbUtilsInternal::__dcm_svc_sql_prepare_to_step_simple(sqlite3 *handle, const char *sql_str, sqlite3_stmt** stmt)
{
- int err = -1;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug("[SQL query] : %s", sql_str);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
- err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
+ ret = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
sqlite3_free((char *)sql_str);
- if (err != SQLITE_OK) {
- dcm_error ("prepare error %d[%s]", err, sqlite3_errmsg(handle));
- if (err == SQLITE_CORRUPT) {
+ if (ret != SQLITE_OK) {
+ dcm_error ("prepare error %d[%s]", ret, sqlite3_errmsg(handle));
+ if (ret == SQLITE_CORRUPT) {
return MS_MEDIA_ERR_DB_CORRUPT;
- } else if (err == SQLITE_PERM) {
+ } else if (ret == SQLITE_PERM) {
return MS_MEDIA_ERR_DB_PERMISSION;
}
int DcmDbUtils::_dcm_svc_db_connect(uid_t uid)
{
- int err = -1;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug("_dcm_svc_db_connect uid: %d", uid);
dcm_uid = uid;
- err = media_db_connect(&db_handle, dcm_uid, TRUE);
- if (err != MS_MEDIA_ERR_NONE) {
- dcm_error("media_db_connect failed: %d", err);
+ ret = media_db_connect(&db_handle, dcm_uid, TRUE);
+ if (ret != MS_MEDIA_ERR_NONE) {
+ dcm_error("media_db_connect failed: %d", ret);
db_handle = NULL;
- return err;
+ return ret;
}
dcm_warn("media db handle: %p", db_handle);
int DcmDbUtils::_dcm_svc_db_disconnect(void)
{
- int err = -1;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_warn("media db handle: %p", db_handle);
if (db_handle != NULL) {
- err = media_db_disconnect(db_handle);
- if (err != MS_MEDIA_ERR_NONE) {
- dcm_error("media_db_disconnect failed: %d", err);
+ ret = media_db_disconnect(db_handle);
+ if (ret != MS_MEDIA_ERR_NONE) {
+ dcm_error("media_db_disconnect failed: %d", ret);
db_handle = NULL;
- return err;
+ return ret;
}
}
dcm_debug_fenter();
- DCM_CHECK_VAL(db_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(file_path, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(db_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(file_path, MS_MEDIA_ERR_INVALID_PARAMETER);
/* Make query */
if (mmc_mounted == true) {
dcm_debug_fenter();
- DCM_CHECK_VAL(db_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(image_list, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(db_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(image_list, MS_MEDIA_ERR_INVALID_PARAMETER);
/* Make query */
if (mmc_mounted == true) {
ret = DcmDbUtilsInternal::__dcm_svc_sql_prepare_to_step_simple((sqlite3 *)db_handle, query_string, &sql_stmt);
if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("error when __dcm_svc_sql_prepare_to_step_simple. ret = [%d]", ret);
- return DCM_ERROR_DB_OPERATION;
+ return ret;
}
while(sqlite3_step(sql_stmt) == SQLITE_ROW) {
static char uuid_unparsed[50] = {0, };
dcm_debug_fenter();
- DCM_CHECK_VAL(face, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(face, MS_MEDIA_ERR_INVALID_PARAMETER);
uuid_generate(uuid_value);
uuid_unparse(uuid_value, uuid_unparsed);
(*face)->face_uuid = g_strdup(uuid_unparsed);
if ((*face)->face_uuid == NULL) {
- ret = DCM_ERROR_UUID_GENERATE_FAILED;
+ ret = MS_MEDIA_ERR_INTERNAL;
} else {
dcm_debug("set face_uuid :%s", (*face)->face_uuid);
}
int DcmDbUtils::_dcm_svc_db_insert_face_to_db(DcmFaceItem *face)
{
- int ret = DCM_SUCCESS;
- int err = MS_MEDIA_ERR_NONE;
+ int ret = MS_MEDIA_ERR_NONE;
char* query_string = NULL;
dcm_debug_fenter();
- DCM_CHECK_VAL(db_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(face, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(face->face_uuid, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(db_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(face, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(face->face_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
if (DcmDbUtilsInternal::__dcm_svc_db_check_duplicated(db_handle, face) == TRUE) {
dcm_error("[__dcm_svc_db_check_duplicated] The data is duplicated!");
- return DCM_ERROR_DUPLICATED_DATA;
+ return MS_MEDIA_ERR_INTERNAL;
}
query_string = sqlite3_mprintf(INSERT_FACE_ITEM_TO_DB, face->face_uuid, face->media_uuid, face->face_rect_x, face->face_rect_y, face->face_rect_w, face->face_rect_h, face->orientation);
dcm_debug("query is %s", query_string);
g_mutex_trylock(&gMutexLock);
- err = media_db_request_update_db(query_string, dcm_uid);
- if (err != MS_MEDIA_ERR_NONE) {
+ ret = media_db_request_update_db(query_string, dcm_uid);
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("media_db_request_update_db fail = %d, %s", ret, sqlite3_errmsg((sqlite3 *)db_handle));
- ret = DCM_ERROR_DB_OPERATION;
}
g_mutex_unlock(&gMutexLock);
int DcmDbUtils::_dcm_svc_db_insert_face_to_face_scan_list(DcmScanItem *scan_item)
{
- int ret = DCM_SUCCESS;
- int err = MS_MEDIA_ERR_NONE;
+ int ret = MS_MEDIA_ERR_NONE;
char* query_string = NULL;
dcm_debug_fenter();
- DCM_CHECK_VAL(db_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(scan_item, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(scan_item->media_uuid, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(db_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item->media_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
if (DcmDbUtilsInternal::__dcm_svc_db_check_duplicated_scan_list(db_handle, scan_item->media_uuid) == TRUE) {
dcm_error("[_dcm_svc_db_insert_face_to_face_scan_list] The data is duplicated!");
- return DCM_ERROR_DUPLICATED_DATA;
+ return MS_MEDIA_ERR_INTERNAL;
}
query_string = sqlite3_mprintf("INSERT INTO %s (media_uuid, storage_uuid) values('%q', '%q')", DB_TABLE_FACE_SCAN_LIST, scan_item->media_uuid, scan_item->storage_uuid);
dcm_debug("query is %s", query_string);
g_mutex_trylock(&gMutexLock);
- err = media_db_request_update_db(query_string, dcm_uid);
- if (err != MS_MEDIA_ERR_NONE) {
+ ret = media_db_request_update_db(query_string, dcm_uid);
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("media_db_request_update_db is failed: %d, %s", ret, sqlite3_errmsg((sqlite3 *)db_handle));
- ret = DCM_ERROR_DB_OPERATION;
}
g_mutex_unlock(&gMutexLock);
int DcmDbUtils::_dcm_svc_db_update_color_to_db(DcmColorItem color)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug_fenter();
#if 0
- int err = MS_MEDIA_ERR_NONE;
char* query_string = NULL;
- DCM_CHECK_VAL(db_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(color.media_uuid, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(color.storage_uuid, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(db_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(color.media_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(color.storage_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
query_string = sqlite3_mprintf(UPDATE_COLOR_ITEM_TO_DB, (int)(color.rgb_r), (int)(color.rgb_g), (int)(color.rgb_b), color.media_uuid, color.storage_uuid);
dcm_debug("query is %s", query_string);
g_mutex_trylock(&gMutexLock);
- err = media_db_request_update_db(query_string, dcm_uid);
- if (err != MS_MEDIA_ERR_NONE) {
+ ret = media_db_request_update_db(query_string, dcm_uid);
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("media_db_request_update_db fail = %d, %s", ret, sqlite3_errmsg((sqlite3 *)db_handle));
- ret = DCM_ERROR_DB_OPERATION;
}
g_mutex_unlock(&gMutexLock);
dcm_debug_fenter();
- DCM_CHECK_VAL(db_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(media_uuid, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(db_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(media_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
query_string = sqlite3_mprintf("SELECT count(*) FROM %s WHERE (media_uuid='%q')", DB_TABLE_FACE_SCAN_LIST, media_uuid);
- DCM_CHECK_VAL(query_string, DCM_ERROR_OUT_OF_MEMORY);
+ DCM_CHECK_VAL(query_string, MS_MEDIA_ERR_OUT_OF_MEMORY);
ret = DcmDbUtilsInternal::__dcm_svc_sql_prepare_to_step((sqlite3 *)db_handle, query_string, &sql_stmt);
if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("error when __dcm_svc_sql_prepare_to_step. ret = [%d]", ret);
- return DCM_ERROR_DB_OPERATION;
+ return ret;
}
count = sqlite3_column_int(sql_stmt, 0);
ret = dcm_face_create(&dcm_face_handle);
if (ret != FACE_ERROR_NONE) {
dcm_error("Failed to dcm_face_create err: %d", ret);
- return DCM_ERROR_FACE_ENGINE_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmFaceUtils::finalize()
dcm_debug_fenter();
- DCM_CHECK_VAL(dcm_face_handle, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(dcm_face_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
ret = dcm_face_destroy(dcm_face_handle);
if (ret != FACE_ERROR_NONE) {
dcm_error("Failed to dcm_face_destroy ret: %d", ret);
- return DCM_ERROR_FACE_ENGINE_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
dcm_face_handle = NULL;
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmFaceUtils::runFaceRecognizeProcess(DcmScanItem *scan_item, DcmImageInfo *image_info)
int i = 0;
double scale_factor = 0.0;
int err = FACE_ERROR_NONE;
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
face_info_s *face_info = NULL;
dcm_debug_fenter();
- DCM_CHECK_VAL(dcm_face_handle, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(scan_item, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(scan_item->media_uuid, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(image_info, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(image_info->pixel, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(dcm_face_handle, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item->media_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(image_info, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(image_info->pixel, MS_MEDIA_ERR_INVALID_PARAMETER);
dcm_debug("colorspce: [%d], w: [%d], h: [%d]", image_info->decode_type, image_info->buffer_width, image_info->buffer_height);
err = dcm_face_set_image_info(dcm_face_handle, (face_image_colorspace_e)image_info->decode_type, image_info->pixel, image_info->buffer_width, image_info->buffer_height, image_info->size);
if (err != FACE_ERROR_NONE) {
dcm_error("Failed to dcm_face_set_image_info! err: %d", err);
- ret = DCM_ERROR_FACE_ENGINE_FAILED;
+ ret = MS_MEDIA_ERR_INTERNAL;
goto DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED;
}
face_info = (face_info_s *)g_malloc0(sizeof(face_info_s));
if (face_info == NULL) {
dcm_error("Failed to allocate face info");
- ret = DCM_ERROR_OUT_OF_MEMORY;
+ ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
goto DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED;
}
err = dcm_face_get_face_info(dcm_face_handle, face_info);
if (err != FACE_ERROR_NONE) {
dcm_error("Failed to get face info! err: %d", err);
- ret = DCM_ERROR_FACE_ENGINE_FAILED;
+ ret = MS_MEDIA_ERR_INTERNAL;
goto DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED;
}
face = NULL;
err = DcmFaceApi::createFaceItem(&face);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to create face items! err: %d", err);
ret = err;
goto DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED;
/* Insert face rectangle into database */
err = dcmDbUtils->_dcm_svc_db_generate_uuid(&face);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to set uuid! err: %d", err);
goto DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED;
}
err = dcmDbUtils->_dcm_svc_db_insert_face_to_db(face);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to insert face item into db! err: %d", err);
goto DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED;
}
DCM_SVC_FACE_RECOGNIZE_BUFFER_FAILED:
err = dcmDbUtils->_dcm_svc_db_insert_face_to_face_scan_list(scan_item);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to insert face item into face_scan_list! err: %d", err);
}
int DcmFaceApi::createFaceItem(DcmFaceItem **face)
{
- DCM_CHECK_VAL(face, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(face, MS_MEDIA_ERR_INVALID_PARAMETER);
*face = NULL;
DcmFaceItem *_face = (DcmFaceItem*)g_malloc0(sizeof(DcmFaceItem));
if (_face == NULL)
- return DCM_ERROR_OUT_OF_MEMORY;
+ return MS_MEDIA_ERR_OUT_OF_MEMORY;
*face = _face;
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
double DcmFaceApi::caculateScaleFactor(DcmImageInfo *image_info)
#include <DcmIpcUtils.h>
#include <DcmTypes.h>
#include <DcmDebugUtils.h>
+#include <media-util.h>
static char DCM_IPC_PATH[][100] = {
{"/var/run/media-server/dcm_ipc_scanthread.socket"},
if ((recv_msg_size = read(client_sock, recv_msg, sizeof(dcmMsg))) < 0) {
if (errno == EWOULDBLOCK) {
dcm_error("Timeout. Can't try any more");
- return DCM_ERROR_IPC;
+ return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
} else {
dcm_stderror("recv failed");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
}
dcm_sec_debug("[receive msg] type: %d, pid: %d, uid: %d, msg: %s, msg_size: %d", recv_msg->msg_type, recv_msg->pid, recv_msg->uid, (recv_msg->msg)?recv_msg->msg:"NULL", recv_msg->msg_size);
if (!(recv_msg->msg_type >= 0 && recv_msg->msg_type < DCM_MSG_MAX)) {
dcm_error("IPC message is wrong!");
- return DCM_ERROR_IPC_INVALID_MSG;
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmIpcUtils::acceptSocket(int serv_sock, int* client_sock)
{
- DCM_CHECK_VAL(client_sock, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(client_sock, MS_MEDIA_ERR_INVALID_PARAMETER);
int sockfd = -1;
struct sockaddr_un client_addr;
socklen_t client_addr_len = sizeof(client_addr);
if ((sockfd = accept(serv_sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
dcm_stderror("accept failed");
*client_sock = -1;
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_ACCEPT;
}
*client_sock = sockfd;
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmIpcUtils::createSocket(int *socket_fd, DcmIpcPortType port)
{
- DCM_CHECK_VAL(socket_fd, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(socket_fd, MS_MEDIA_ERR_INVALID_PARAMETER);
int sock = -1;
struct sockaddr_un serv_addr;
bool bind_success = false;
/* Create a new TCP socket */
if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
dcm_stderror("socket failed");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
/* Set socket address */
if (bind_success == false) {
dcm_stderror("bind failed");
close(sock);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_BIND;
}
dcm_debug("bind success");
- /* Listenint */
+ /* Listen */
if (listen(sock, SOMAXCONN) < 0) {
dcm_stderror("listen failed");
close(sock);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
dcm_debug("Listening...");
*socket_fd = sock;
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmIpcUtils::sendClientSocketMsg(int socket_fd, ms_dcm_msg_type_e msg_type, unsigned int result, const char *msg, DcmIpcPortType port)
{
if (port < 0 || port >= DCM_IPC_PORT_MAX) {
dcm_error("Invalid port! Stop sending message...");
- return DCM_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
- dcm_debug("Send message type: %d %s %d", msg_type, msg, result);
+ dcm_debug("Send message type: [%d] msg : [%s] result : [%d]", msg_type, msg, result);
dcmMsg send_msg;
int sock = -1;
if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
dcm_stderror("socket failed");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
dcm_stderror("setsockopt failed");
close(sock);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sun_family = AF_UNIX;
strncpy(serv_addr.sun_path, DCM_IPC_PATH[port], sizeof(DCM_IPC_PATH[port]));
-
+
/* Connecting to the thumbnail server */
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
dcm_stderror("connect");
close(sock);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
} else {
sock = socket_fd;
if (send_msg.msg_size >= DCM_IPC_MSG_MAX_SIZE) {
dcm_error("Message size is invalid!");
close(sock);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
/* Send msg to the socket */
if (send(sock, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
dcm_stderror("send failed");
close(sock);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
dcm_debug("Sent message type: %d %d", send_msg.msg_type, send_msg.result);
close(sock);
- return DCM_SUCCESS;
+
+ return MS_MEDIA_ERR_NONE;
}
int DcmIpcUtils::sendSocketMsg(ms_dcm_msg_type_e msg_type, uid_t uid, const char *msg, DcmIpcPortType port)
{
if (port < 0 || port >= DCM_IPC_PORT_MAX) {
dcm_error("Invalid port! Stop sending message...");
- return DCM_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
dcm_debug_fenter();
/* If message size is larget than max_size, then message is invalid */
if (send_msg.msg_size >= DCM_IPC_MSG_MAX_SIZE) {
dcm_error("Message size is invalid!");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
/* Create a new TCP socket */
if ((socket_fd = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
dcm_stderror("socket failed");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
/* Set dcm thread socket address */
if (connect(socket_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
dcm_stderror("connect error");
close(socket_fd);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
/* Send msg to the socket */
if (send(socket_fd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
dcm_stderror("send failed");
close(socket_fd);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
close(socket_fd);
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmIpcUtils::sendCompleteMsg(ms_dcm_msg_type_e msg_type, const unsigned int count, const char *msg, DcmIpcPortType port)
{
if (port < 0 || port >= DCM_IPC_PORT_MAX) {
dcm_error("Invalid port! Stop sending message...");
- return DCM_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
dcm_debug_fenter();
/* If message size is larget than max_size, then message is invalid */
if (send_msg.msg_size >= DCM_IPC_MSG_MAX_SIZE) {
dcm_error("Message size is invalid!");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
/* Create a new TCP socket */
if ((socket_fd = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
dcm_stderror("socket failed");
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
/* Set dcm thread socket address */
if (connect(socket_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
dcm_stderror("connect error");
close(socket_fd);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
/* Send msg to the socket */
if (send(socket_fd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
dcm_stderror("send failed");
close(socket_fd);
- return DCM_ERROR_NETWORK;
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
close(socket_fd);
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmIpcUtils::closeSocket(int socket_fd)
{
close(socket_fd);
- return DCM_SUCCESS;
+
+ return MS_MEDIA_ERR_NONE;
}
DCM_CHECK_FALSE(data);
ret = DcmIpcUtils::sendSocketMsg(DCM_MSG_SCAN_TERMINATED, 0, NULL, DCM_IPC_PORT_DCM_RECV);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("send to terminated messge to DCM Main");
}
}
scan_thread_quit_timer = g_timeout_source_new_seconds(DCM_SVC_SCAN_THREAD_TIMEOUT_SEC);
- DCM_CHECK_VAL(scan_thread_quit_timer, DCM_ERROR_OUT_OF_MEMORY);
+ DCM_CHECK_VAL(scan_thread_quit_timer, MS_MEDIA_ERR_OUT_OF_MEMORY);
g_source_set_callback(scan_thread_quit_timer, DcmScanCallback::quitTimerAtScanThread, (gpointer)this, NULL);
g_source_attach(scan_thread_quit_timer, scan_thread_main_context);
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::getMmcState(void)
int DcmScanSvc::prepareImageList()
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
DcmDbUtils *dcmDbUtils = DcmDbUtils::getInstance();
bool mmc_mounted = false;
if (scan_all_item_list == NULL) {
dcm_debug("No image list for scanning");
- return DCM_ERROR_DB_NO_RESULT;
+ return MS_MEDIA_ERR_DB_NO_RECORD;
}
if ((scan_all_item_list != NULL) && (g_list_length(scan_all_item_list) == 0)) {
dcm_debug("No image list from db!");
- return DCM_ERROR_DB_NO_RESULT;
+ return MS_MEDIA_ERR_DB_NO_RECORD;
}
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::prepareImageListByPath(const char *file_path)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
DcmDbUtils *dcmDbUtils = DcmDbUtils::getInstance();
bool mmc_mounted = false;
if (scan_single_item_list == NULL) {
dcm_debug("No image list for scanning");
- return DCM_ERROR_DB_NO_RESULT;
+ return MS_MEDIA_ERR_DB_NO_RECORD;
}
if ((scan_single_item_list != NULL) && (g_list_length(scan_single_item_list) == 0)) {
dcm_debug("No image list from db!");
- return DCM_ERROR_DB_NO_RESULT;
+ return MS_MEDIA_ERR_DB_NO_RECORD;
}
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::clearAllItemList()
scan_all_curr_index = 0;
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::clearSingleItemList()
scan_single_curr_index = 0;
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::initialize()
DcmFaceUtils::initialize();
dcmDBUtils = DcmDbUtils::getInstance();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::finalize()
clearSingleItemList();
DcmFaceUtils::finalize();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::sendCompletedMsg(const char *msg, const unsigned int count, DcmIpcPortType port)
dcm_warn("Scan operation is not finished yet. Keep scanning...");
}
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::sendTerminatedMsg()
{
dcm_debug("Terminated message is sent to DCM main...");
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::getScanStatus(DcmScanItem *scan_item, bool *media_scanned)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
DcmDbUtils *dcmDbUtils = DcmDbUtils::getInstance();
- DCM_CHECK_VAL(scan_item, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(scan_item->media_uuid, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item->media_uuid, MS_MEDIA_ERR_INVALID_PARAMETER);
/* Check if this media is scanned or not */
ret = dcmDbUtils->_dcm_svc_db_check_scanned_by_media_uuid(scan_item->media_uuid, media_scanned);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to check if this media item is scanned or not!");
}
int DcmScanSvc::runScanProcess(DcmScanItem *scan_item)
{
bool media_scanned = false;
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug_fenter();
- DCM_CHECK_VAL(scan_item, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(scan_item->file_path, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(scan_item->file_path, MS_MEDIA_ERR_INVALID_PARAMETER);
DcmImageInfo image_info = {0, };
memset(&image_info, 0, sizeof(DcmImageInfo));
* Media information will be inserted after face is detected.
* If media uuid does not exist, retry is needed */
ret = getScanStatus(scan_item, &media_scanned);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to get scan item info from db! err: %d", ret);
return ret;
}
if (media_scanned == true) {
dcm_warn("This media is scanned already! Skip...");
DCM_SAFE_FREE(image_info.pixel);
- return DCM_ERROR_IMAGE_ALREADY_SCANNED;
+ return MS_MEDIA_ERROR_ALREADY_SCANNED;
} else {
dcm_debug("This media is NOT scanned yet.");
}
if (image_info.original_width <= 0 && image_info.original_height <= 0) {
ret = ImgGetImageInfo((const char *)(scan_item->file_path), &type, &(image_info.original_width), &(image_info.original_height));
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed ImgGetImageInfo! err: %d", ret);
return ret;
}
image_format = DCM_IMAGE_FORMAT_RGBA;
} else {
dcm_error("Failed not supported type! (%s)", scan_item->mime_type);
- return DCM_ERROR_INVALID_PARAMETER;
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
}
ret = dcm_decode_image((const char *) (scan_item->file_path), image_format, scan_item->mime_type,
image_info.orientation, FALSE, &(image_info.pixel), &(image_info.size),
&(image_info.buffer_width), &(image_info.buffer_height));
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed dcm_decode_image! err: %d", ret);
return ret;
}
/* Process face scan */
ret = DcmFaceUtils::runFaceRecognizeProcess(scan_item, &image_info);
- if (ret != DCM_SUCCESS)
+ if (ret != MS_MEDIA_ERR_NONE)
dcm_error("Failed to process face detection! err: %d", ret);
#if 0
/* Process color extract */
ret = DcmColorUtils::runColorExtractProcess(scan_item, &image_info);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to process color extraction! err: %d", ret);
}
#endif
int DcmScanSvc::ScanAllItems()
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug_fenter();
clearAllItemList();
ret = prepareImageList();
- if (ret == DCM_ERROR_DB_NO_RESULT) {
+ if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
dcm_debug("No items to Scan. Scan operation completed!!!");
clearAllItemList();
/* Send scan complete message to main thread (if all scan operations are finished) */
sendCompletedMsg( NULL, 0, DCM_IPC_PORT_DCM_RECV);
ret = dcmDBUtils->_dcm_svc_db_disconnect();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to disconnect db! err: %d", ret);
}
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
/* DCM scan started */
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::ScanSingleItem(const char *file_path)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
DcmScanItem *scan_item = NULL;
DcmDbUtils *dcmDbUtils = DcmDbUtils::getInstance();
int face_count = 0;
- DCM_CHECK_VAL(file_path, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(file_path, MS_MEDIA_ERR_INVALID_PARAMETER);
dcm_debug_fenter();
clearSingleItemList();
ret = prepareImageListByPath(file_path);
- if (ret == DCM_ERROR_DB_NO_RESULT) {
+ if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
dcm_debug("No items to Scan. Scan operation completed!!!");
clearSingleItemList();
/* Send scan complete message to main thread (if all scan operations are finished) */
sendCompletedMsg( file_path/*ret*/, 0, DCM_IPC_PORT_DCM_RECV);
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
dcm_debug("append scan item to scan item list");
dcm_sec_debug("current index: %d, path: %s, scan type: %d", scan_single_curr_index, scan_item->file_path, scan_item->scan_item_type);
ret = runScanProcess(scan_item);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to process scan job! err: %d", ret);
/* If the scan item is not scanned, insert media uuid into face_scan_list */
- if (ret != DCM_ERROR_IMAGE_ALREADY_SCANNED) {
+ if (ret != MS_MEDIA_ERROR_ALREADY_SCANNED) {
dcmDbUtils->_dcm_svc_db_insert_face_to_face_scan_list(scan_item);
}
}
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanMain::ScanSingle(const char *file_path, uid_t uid, int *face_count)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
DcmScanSvc dcmScanSvc;
DcmScanItem *scan_item = NULL;
unsigned int list_len = 0;
- DCM_CHECK_VAL(file_path, DCM_ERROR_INVALID_PARAMETER);
- DCM_CHECK_VAL(face_count, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(file_path, MS_MEDIA_ERR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(face_count, MS_MEDIA_ERR_INVALID_PARAMETER);
dcm_debug_fenter();
/* Init global variables */
ret = dcmScanSvc.initialize();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to initialize scan thread global variable! err: %d", ret);
goto DCM_SVC_SCAN_SINGLE_FAILED;
}
dcmScanSvc.clearSingleItemList();
ret = dcmScanSvc.dcmDBUtils->_dcm_svc_db_connect(uid);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to connect db! err: %d", ret);
}
ret = dcmScanSvc.prepareImageListByPath(file_path);
- if (ret == DCM_ERROR_DB_NO_RESULT) {
+ if (ret == MS_MEDIA_ERR_DB_NO_RECORD) {
dcm_debug("No items to Scan. Scan operation completed!!!");
dcmScanSvc.clearSingleItemList();
goto DCM_SVC_SCAN_SINGLE_FAILED;
dcm_sec_debug("current index: %d, path: %s, scan type: %d", dcmScanSvc.scan_single_curr_index, scan_item->file_path, scan_item->scan_item_type);
ret = dcmScanSvc.runScanProcess(scan_item);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to process scan job! err: %d", ret);
/* If the scan item is not scanned, insert media uuid into face_scan_list */
- if (ret != DCM_ERROR_IMAGE_ALREADY_SCANNED) {
+ if (ret != MS_MEDIA_ERROR_ALREADY_SCANNED) {
dcmScanSvc.dcmDBUtils->_dcm_svc_db_insert_face_to_face_scan_list(scan_item);
}
}
DCM_SVC_SCAN_SINGLE_FAILED:
ret = dcmScanSvc.dcmDBUtils->_dcm_svc_db_disconnect();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to disconnect db! err: %d", ret);
}
dcmScanSvc.clearSingleItemList();
ret = dcmScanSvc.finalize();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to de-initialize scan thread global variable! err: %d", ret);
}
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
int DcmScanSvc::terminateScanOperations()
int DcmScanSvc::receiveMsg(dcmMsg *recv_msg)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
dcmDBUtils = DcmDbUtils::getInstance();
g_uid = recv_msg->uid;
- DCM_CHECK_VAL(recv_msg, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(recv_msg, MS_MEDIA_ERR_INVALID_PARAMETER);
dcm_debug("msg_type: %d", recv_msg->msg_type);
{
/* Destroy scan idles, and quit scan thread main loop */
ret = terminateScanOperations();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to terminate DCM scan service! err: %d", ret);
- return DCM_ERROR_DB_OPERATION;
}
+
return ret;
}
else if (recv_msg->msg_type == DCM_MSG_REQUEST_ALL_MEDIA)
{
/* Use timer to scan all unscanned images */
ret = dcmDBUtils->_dcm_svc_db_connect(recv_msg->uid);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to disconnect db! err: %d", ret);
}
ScanAllItems();
}
else {
dcm_error("Invalid message type(%d)!", recv_msg->msg_type);
- ret = DCM_ERROR_IPC_INVALID_MSG;
+ ret = MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
return ret;
/* Accept tcp client socket */
err = DcmIpcUtils::acceptSocket(sock, &client_sock);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to accept tcp socket! err: %d", err);
return TRUE;
}
/* Receive message from tcp socket */
err = DcmIpcUtils::receiveSocketMsg(client_sock, &recv_msg);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to receive tcp msg! err: %d", err);
goto DCM_SVC_SCAN_READ_THREAD_RECV_SOCKET_FAILED;
}
/* Process received message */
err = dcmScanSvc->receiveMsg(&recv_msg);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Error ocurred when process received message: %d", err);
goto DCM_SVC_SCAN_READ_THREAD_RECV_SOCKET_FAILED;
}
gboolean DcmScanCallback::runScanThreadIdle(gpointer data)
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
DcmScanSvc *scanSvc = (DcmScanSvc *)data;
DcmScanItem *scan_item = NULL;
DcmDbUtils *dcmDbUtils = DcmDbUtils::getInstance();
DCM_CHECK_FALSE(dcmDbUtils);
ret = scanSvc->dcmDBUtils->_dcm_svc_db_connect(scanSvc->g_uid);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to disconnect db! err: %d", ret);
}
/* DCM scan started */
dcm_sec_debug("current index: %d, path: %s state: %s", scanSvc->scan_all_curr_index, scan_item->file_path, (scanSvc->g_scan_cancel)?"cancel":"go");
ret = scanSvc->runScanProcess(scan_item);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to process scan job! err: %d", ret);
/* If the scan item is not scanned, insert media uuid into face_scan_list */
- if (ret != DCM_ERROR_IMAGE_ALREADY_SCANNED) {
+ if (ret != MS_MEDIA_ERROR_ALREADY_SCANNED) {
dcmDbUtils->_dcm_svc_db_insert_face_to_face_scan_list(scan_item);
}
}
dcm_warn("All images are scanned. Scan operation completed");
scanSvc->clearAllItemList();
ret = scanSvc->dcmDBUtils->_dcm_svc_db_disconnect();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to disconnect db! err: %d", ret);
}
scanSvc->clearAllItemList();
return FALSE;
}
ret = scanSvc->dcmDBUtils->_dcm_svc_db_disconnect();
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to disconnect db! err: %d", ret);
}
GSource *scan_thread_ready_idle = NULL;
int err = 0;
- DCM_CHECK_VAL(data, DCM_ERROR_INVALID_PARAMETER);
+ DCM_CHECK_VAL(data, MS_MEDIA_ERR_INVALID_PARAMETER);
/* Create TCP Socket to receive message from main thread */
err = DcmIpcUtils::createSocket(&socket_fd, DCM_IPC_PORT_SCAN_RECV);
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to create socket! err: %d", err);
goto DCM_SVC_SCAN_CREATE_SCAN_THREAD_FAILED;
}
/* Init global variables */
err = dcmScanSvc.initialize();
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to initialize scan thread global variable! err: %d", err);
goto DCM_SVC_SCAN_CREATE_SCAN_THREAD_FAILED;
}
DCM_SVC_SCAN_CREATE_SCAN_THREAD_FAILED:
err = dcmScanSvc.finalize();
- if (err != DCM_SUCCESS) {
+ if (err != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to de-initialize scan thread global variable! err: %d", err);
}
#include <DcmTypes.h>
#include <DcmScanSvc.h>
#include <DcmDebugUtils.h>
+#include <media-util.h>
#define DCM_SVC_MAIN_THREAD_TIMEOUT_SEC 1
void DcmMainSvc::dcmServiceStartjobs(void)
{
- if (createScanThread() != DCM_SUCCESS) {
+ if (createScanThread() != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to create scan thread! Exit main thread...");
}
/* Send ready response to dcm launcher */
- if (DcmIpcUtils::sendSocketMsg(DCM_MSG_SERVER_READY, 0, NULL, DCM_IPC_PORT_MS_RECV) != DCM_SUCCESS) {
+ if (DcmIpcUtils::sendSocketMsg(DCM_MSG_SERVER_READY, 0, NULL, DCM_IPC_PORT_MS_RECV) != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to send ready message");
}
}
int DcmMainSvc::waitScanThreadReady()
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
dcmMsg *async_queue_msg = NULL;
/* Wait until the scan thread is ready (timeout: 5 sec) */
async_queue_msg = (dcmMsg *)g_async_queue_timeout_pop(scan_thread_ready, 5000000);
if (async_queue_msg == NULL) {
dcm_error("Async queue timeout!");
- return DCM_ERROR_ASYNC_QUEUE_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* Check if scan thread is created */
scan_thread_ready = NULL;
} else {
dcm_error("Invalid async queue message!");
- ret = DCM_ERROR_ASYNC_QUEUE_FAILED;
+ ret = MS_MEDIA_ERR_INTERNAL;
}
/* Free the received ipc message */
int DcmMainSvc::createScanThread()
{
- int ret = DCM_SUCCESS;
+ int ret = MS_MEDIA_ERR_NONE;
dcm_debug_fenter();
scan_thread_ready = g_async_queue_new();
if (scan_thread_ready == NULL) {
dcm_error("Failed to create async queue!");
- return DCM_ERROR_ASYNC_QUEUE_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
/* Create the scan thread */
scan_thread = g_thread_new("dcm_scan_thread", (GThreadFunc) DcmScanMain::runScanThread, (gpointer) this);
if (scan_thread == NULL) {
dcm_error("Failed to create scan thread!");
- return DCM_ERROR_CREATE_THREAD_FAILED;
+ return MS_MEDIA_ERR_INTERNAL;
}
ret = waitScanThreadReady();
/* Wait until scan thread is ready */
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to wait for scan thread to be ready! err: %d", ret);
return ret;
}
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
gboolean DcmMainSvcCallBack::readMsg(GIOChannel *src, GIOCondition condition, gpointer data)
/* Accept tcp client socket */
ret = DcmIpcUtils::acceptSocket(sock, &client_sock);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to accept tcp socket! err: %d", ret);
return TRUE;
}
if (dcmSvc->scan_thread == NULL) {
dcm_debug("scan thread is not started yet!");
/* Create scan thread before main loop is started */
- if (dcmSvc->createScanThread() != DCM_SUCCESS) {
+ if (dcmSvc->createScanThread() != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to create scan thread! Exit main thread...");
DcmIpcUtils::closeSocket(client_sock);
return TRUE;
ret = DcmIpcUtils::sendSocketMsg(DCM_MSG_REQUEST_KILL_SERVER, recv_msg.uid, recv_msg.msg, DCM_IPC_PORT_SCAN_RECV);
} else if (recv_msg.msg_type == DCM_MSG_REQUEST_ALL_MEDIA) {
ret = DcmIpcUtils::sendSocketMsg(DCM_MSG_REQUEST_ALL_MEDIA, recv_msg.uid, NULL, DCM_IPC_PORT_SCAN_RECV);
- if (ret == DCM_SUCCESS) {
+ if (ret == MS_MEDIA_ERR_NONE) {
ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_MSG_REQUEST_ALL_MEDIA, recv_msg.uid, NULL, DCM_IPC_PORT_DCM_RECV);
}
} else if (recv_msg.msg_type == DCM_MSG_REQUEST_MEDIA) {
dcm_debug("Scan single");
ret = DcmScanMain::ScanSingle(recv_msg.msg, recv_msg.uid, &face_count);
- dcm_debug("Scan single result: %d (%d)", ret, face_count);
- if (ret == DCM_SUCCESS) {
+ dcm_debug("Scan single result: ret : [%d] face_count : [%d])", ret, face_count);
+ if (ret == MS_MEDIA_ERR_NONE) {
ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_MSG_REQUEST_MEDIA, face_count, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to sendClientSocketMsg! err: %d", ret);
}
} else {
ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_MSG_REQUEST_MEDIA, ret, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
- if (ret != DCM_SUCCESS) {
+ if (ret != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to sendClientSocketMsg! err: %d", ret);
}
}
}
quit_timer = g_timeout_source_new_seconds(DCM_SVC_MAIN_THREAD_TIMEOUT_SEC);
- DCM_CHECK_VAL(quit_timer, DCM_ERROR_OUT_OF_MEMORY);
+ DCM_CHECK_VAL(quit_timer, MS_MEDIA_ERR_OUT_OF_MEMORY);
g_source_set_callback(quit_timer, DcmMainSvcCallBack::quitTimerAtMainLoop, (gpointer) this, NULL);
g_source_attach(quit_timer, main_loop_context);
dcm_debug_fleave();
- return DCM_SUCCESS;
+ return MS_MEDIA_ERR_NONE;
}
void DcmMainSvc::quitDcmSvcMainLoop()
GMainContext *context = NULL;
/* Create and bind new socket to mainloop */
- if (DcmIpcUtils::createSocket(&sockfd, DCM_IPC_PORT_DCM_RECV) != DCM_SUCCESS) {
+ if (DcmIpcUtils::createSocket(&sockfd, DCM_IPC_PORT_DCM_RECV) != MS_MEDIA_ERR_NONE) {
dcm_error("Failed to create socket");
return -1;
}
projects / platform / core / multimedia / dcm-service.git / commitdiff