Improve tag related function

[platform/core/api/media-content.git] / src / media_db.c

diff --git a/src/media_db.c b/src/media_db.c
index 26f866e..08b8ab5 100755 (executable)
--- a/src/media_db.c
+++ b/src/media_db.c
@@ -184,11 +184,11 @@ static int __media_db_make_query(filter_h filter, char **condition_query, char *
        int ret = MEDIA_CONTENT_ERROR_NONE;
        filter_s *_filter = (filter_s *)filter;
 
-       media_content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
+       content_retv_if(!_filter, MEDIA_CONTENT_ERROR_NONE);
 
        if (STRING_VALID(_filter->condition)) {
                ret = _media_filter_build_condition(_filter->is_full_condition, _filter->condition, _filter->condition_collate_type, condition_query);
-               media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+               content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
        }
 
        ret = _media_filter_build_option(filter, option_query);
@@ -251,7 +251,7 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                break;
 
        default:
-               media_content_error("Invalid group type [%d]", group_type);
+               content_error("Invalid group type [%d]", group_type);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
@@ -265,7 +265,7 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
        g_free(select_query);
        g_free(condition_query);
        g_free(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *group_count = sqlite3_column_int(stmt, 0);
@@ -303,7 +303,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
        }
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (option_query) {
                tmp_option = g_strconcat(option_query, ")", NULL);
@@ -316,7 +316,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *group_count = sqlite3_column_int(stmt, 0);
@@ -353,12 +353,12 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
        }
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
@@ -393,7 +393,7 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        const char* group_name = __media_db_get_group_name(group);
        if (!STRING_VALID(group_name)) {
                ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-               media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+               content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
        }
 
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
@@ -414,7 +414,7 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (STRING_VALID(option_query))
                snprintf(group_query, sizeof(group_query), "GROUP BY %s %s", group_name, option_query);
@@ -424,7 +424,7 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0)))
@@ -495,7 +495,7 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                break;
 
        default:
-               media_content_error("Invalid group type [%d]", group_type);
+               content_error("Invalid group type [%d]", group_type);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
@@ -509,7 +509,7 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
        g_free(select_query);
        g_free(condition_query);
        g_free(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *group_count = sqlite3_column_int(stmt, 0);
@@ -543,7 +543,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        g_free(select_query);
        g_free(condition_query);
        g_free(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *group_count = sqlite3_column_int(stmt, 0);
@@ -578,7 +578,7 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
        g_free(select_query);
        g_free(condition_query);
        g_free(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
@@ -619,18 +619,18 @@ int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_dat
                snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
 #endif
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_album_s *album = (media_album_s*)calloc(1, sizeof(media_album_s));
 
                if (album == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -675,18 +675,18 @@ int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_d
                snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
 #endif
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_folder_s *_folder = (media_folder_s*)calloc(1, sizeof(media_folder_s));
 
                if (_folder == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -718,18 +718,18 @@ int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *us
        sqlite3_stmt *stmt = NULL;
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(SELECT_PLAYLIST_LIST, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_playlist_s *_playlist = (media_playlist_s*)calloc(1, sizeof(media_playlist_s));
 
                if (_playlist == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -770,7 +770,7 @@ int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_membe
        g_free(select_query);
        g_free(condition_query);
        g_free(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                int playlist_member_id = 0;
@@ -779,7 +779,7 @@ int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_membe
                media_info_s *_media = (media_info_s*)calloc(1, sizeof(media_info_s));
 
                if (_media == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -822,13 +822,13 @@ int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callba
        g_free(select_query);
        g_free(condition_query);
        g_free(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_tag_s *_tag = (media_tag_s*)calloc(1, sizeof(media_tag_s));
 
                if (_tag == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -882,18 +882,18 @@ int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark
 #endif
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_bookmark_s *bookmark = (media_bookmark_s*)calloc(1, sizeof(media_bookmark_s));
 
                if (bookmark == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -951,18 +951,18 @@ int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb call
        }
 #endif
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_face_s *face = (media_face_s*)calloc(1, sizeof(media_face_s));
 
                if (face == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1025,17 +1025,17 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
                break;
 
        default:
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *item_count = sqlite3_column_int(stmt, 0);
@@ -1162,12 +1162,12 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
                break;
 #endif
        default:
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (need_bracket) {
                tmp_option = g_strconcat(option_query, ")", NULL);
@@ -1178,7 +1178,7 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *item_count = sqlite3_column_int(stmt, 0);
@@ -1243,22 +1243,22 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb
                break;
 
        default:
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
                if (item == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1324,22 +1324,22 @@ int _media_db_get_group_item(const char *group_name, filter_h filter, media_info
                break;
 
        default:
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
                if (item == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1384,7 +1384,7 @@ int _media_db_get_group_item_by_union_select(const char *group_name, filter_h fi
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                SAFE_FREE(condition_query1);
                SAFE_FREE(option_query1);
-               media_content_error("create select_query1 failed");
+               content_error("create select_query1 failed");
                return ret;
        }
 
@@ -1401,7 +1401,7 @@ int _media_db_get_group_item_by_union_select(const char *group_name, filter_h fi
                SAFE_FREE(option_query1);
                SAFE_FREE(condition_query2);
                SAFE_FREE(option_query2);
-               media_content_error("create select_query2 failed");
+               content_error("create select_query2 failed");
                return ret;
        }
 
@@ -1410,12 +1410,12 @@ int _media_db_get_group_item_by_union_select(const char *group_name, filter_h fi
        SAFE_FREE(option_query1);
        SAFE_FREE(condition_query2);
        SAFE_FREE(option_query2);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
                if (item == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1499,7 +1499,7 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        }
 #endif
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        /* If 'filter' is not NULL, 'option_query' must be created. */
        if (option_query) {
@@ -1513,7 +1513,7 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *item_count = sqlite3_column_int(stmt, 0);
@@ -1559,17 +1559,17 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
        }
 #endif
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_info_s *item = (media_info_s*)calloc(1, sizeof(media_info_s));
                if (item == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1597,18 +1597,18 @@ int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user
        sqlite3_stmt *stmt = NULL;
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(SELECT_STORAGE_LIST, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_storage_s *_storage = (media_storage_s*)calloc(1, sizeof(media_storage_s));
 
                if (_storage == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1640,12 +1640,12 @@ int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id
 
        ret = _content_get_result(select_query, &stmt);
        SQLITE3_SAFE_FREE(select_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW) {
                *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
        } else {
-               media_content_error("Invalid media_id[%s]", media_id);
+               content_error("Invalid media_id[%s]", media_id);
                ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
@@ -1679,17 +1679,17 @@ int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_pvr_s *item = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
                if (item == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1893,18 +1893,18 @@ int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
                SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_pvr_s *_pvr = (media_pvr_s*)calloc(1, sizeof(media_pvr_s));
 
                if (_pvr == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }
@@ -1992,18 +1992,18 @@ int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
                SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        while (sqlite3_step(stmt) == SQLITE_ROW) {
                media_uhd_s *_uhd = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
 
                if (_uhd == NULL) {
-                       media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
+                       content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
                        SQLITE3_FINALIZE(stmt);
                        return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
                }