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 c706636..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);
@@ -203,71 +203,69 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
        sqlite3_stmt *stmt = NULL;
-       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *select_query = NULL;
        char *condition_query = NULL;
        char *option_query = NULL;
        filter_s *_filter = (filter_s *)filter;
 
-       memset(select_query, 0x00, sizeof(select_query));
-
        switch (group_type) {
        case MEDIA_GROUP_ALBUM:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, _filter->storage_id);
+                       select_query = g_strdup_printf(SELECT_ALBUM_COUNT, _filter->storage_id);
                else
-                       snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
-
+                       select_query = g_strdup_printf(SELECT_ALBUM_COUNT, DB_VIEW_MEDIA);
                break;
+
        case MEDIA_GROUP_FOLDER:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
+                       select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
                else
-                       snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
-
+                       select_query = g_strdup_printf(SELECT_FOLDER_COUNT, DB_VIEW_MEDIA);
                break;
+
        case MEDIA_GROUP_PLAYLIST:
-               if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
-                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-               }
+               select_query = g_strdup(SELECT_PLAYLIST_COUNT);
                break;
+
        case MEDIA_GROUP_TAG:
-               if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
-                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-               }
+               select_query = g_strdup(SELECT_TAG_COUNT);
                break;
+
        case MEDIA_GROUP_BOOKMARK:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, _filter->storage_id);
+                       select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, _filter->storage_id);
                else
-                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
+                       select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT, DB_VIEW_MEDIA);
 
                break;
+
        case MEDIA_GROUP_STORAGE:
-               if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
-                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-               }
+               select_query = g_strdup(SELECT_STORAGE_COUNT);
                break;
+
        case MEDIA_GROUP_FACE:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, _filter->storage_id);
+                       select_query = g_strdup_printf(SELECT_FACE_COUNT, _filter->storage_id);
                else
-                       snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, DB_VIEW_MEDIA);
+                       select_query = g_strdup_printf(SELECT_FACE_COUNT, DB_VIEW_MEDIA);
                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;
        }
 
        ret = __media_db_make_query(filter, &condition_query, &option_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+       if (ret != MEDIA_CONTENT_ERROR_NONE) {
+               g_free(select_query);
+               return 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);
+       g_free(select_query);
+       g_free(condition_query);
+       g_free(option_query);
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (sqlite3_step(stmt) == SQLITE_ROW)
                *group_count = sqlite3_column_int(stmt, 0);
@@ -284,6 +282,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        char select_query[MAX_QUERY_SIZE] = {0, };
        char *condition_query = NULL;
        char *option_query = NULL;
+       char *tmp_option = NULL;
        filter_s *_filter = (filter_s *)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
@@ -304,24 +303,20 @@ 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);
 
-       SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
-       if (STRING_VALID(condition_query)) {
-               SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
-               SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
+       if (option_query) {
+               tmp_option = g_strconcat(option_query, ")", NULL);
+               g_free(option_query);
+               option_query = tmp_option;
+       } else {
+               SAFE_STRLCAT(select_query, ")", sizeof(select_query));
        }
-       if (STRING_VALID(option_query))
-               SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
-       SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
-
-       SAFE_FREE(condition_query);
-       SAFE_FREE(option_query);
 
        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);
@@ -358,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));
@@ -395,10 +390,10 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        memset(select_query, 0x00, sizeof(select_query));
        memset(group_query, 0x00, sizeof(group_query));
 
-       char* group_name = __media_db_get_group_name(group);
+       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*/
@@ -419,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);
@@ -429,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)))
@@ -463,21 +458,23 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                        select_query = g_strdup_printf(SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
                else
                        select_query = g_strdup(SELECT_ALBUM_COUNT);
-
                break;
+
        case MEDIA_GROUP_FOLDER:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        select_query = g_strdup_printf(SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
                else
                        select_query = g_strdup(SELECT_FOLDER_COUNT);
-
                break;
+
        case MEDIA_GROUP_PLAYLIST:
                select_query = g_strdup(SELECT_PLAYLIST_COUNT);
                break;
+
        case MEDIA_GROUP_TAG:
                select_query = g_strdup(SELECT_TAG_COUNT);
                break;
+
        case MEDIA_GROUP_BOOKMARK:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        select_query = g_strdup_printf(SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
@@ -485,17 +482,20 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                        select_query = g_strdup(SELECT_BOOKMARK_COUNT);
 
                break;
+
        case MEDIA_GROUP_STORAGE:
                select_query = g_strdup(SELECT_STORAGE_COUNT);
                break;
+
        case MEDIA_GROUP_FACE:
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        select_query = g_strdup_printf(SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
                else
                        select_query = g_strdup(SELECT_FACE_COUNT);
                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;
                }
@@ -1001,7 +1001,8 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
 
        memset(select_query, 0x00, sizeof(select_query));
 
-       if (group_type == MEDIA_GROUP_ALBUM) {
+       switch (group_type) {
+       case MEDIA_GROUP_ALBUM:
 #ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
@@ -1013,22 +1014,28 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
 #endif
-       } else if (group_type == MEDIA_GROUP_PLAYLIST) {
+               break;
+
+       case MEDIA_GROUP_PLAYLIST:
                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
-       } else if (group_type == MEDIA_GROUP_TAG) {
+               break;
+
+       case MEDIA_GROUP_TAG:
                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_TAG, group_id);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               break;
+
+       default:
+               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);
@@ -1043,126 +1050,135 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
        int ret = MEDIA_CONTENT_ERROR_NONE;
        sqlite3_stmt *stmt = NULL;
        char select_query[MAX_QUERY_SIZE] = {0, };
-       char *tmp_query = NULL;
        char *condition_query = NULL;
        char *option_query = NULL;
-       bool is_simple = FALSE;
+       char *tmp_option = NULL;
+       bool need_bracket = false;
        filter_s *_filter = (filter_s *)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
 
-       if (group_type == MEDIA_GROUP_NONE) {
-               /* There are 2 ways to get count for media table for performance
-                       If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
-                       If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
-               if (_filter && ((_filter->offset < 0) && (_filter->count < 0))) {
+       switch (group_type) {
+       case MEDIA_GROUP_NONE:
+               if (!_filter) {
 #ifdef _USE_TVPD_MODE
-                               if (STRING_VALID(_filter->storage_id))
-                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
-                               else
-                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
 #else
-                               if (STRING_VALID(_filter->storage_id))
-                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
-                               else
-                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
+#endif
+                       break;
+               }
+
+               if (_filter->offset < 0 && _filter->count < 0) {
+#ifdef _USE_TVPD_MODE
+                       if (STRING_VALID(_filter->storage_id))
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
+                       else
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
+#else
+                       if (STRING_VALID(_filter->storage_id))
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
+                       else
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
 #endif
-                               is_simple = TRUE;
                } else {
 #ifdef _USE_TVPD_MODE
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
+                       if (STRING_VALID(_filter->storage_id))
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, _filter->storage_id);
+                       else
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
 #else
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
+                       if (STRING_VALID(_filter->storage_id))
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_BY_STORAGE_ID, _filter->storage_id);
+                       else
+                               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
+
 #endif
+                       need_bracket = true;
                }
-       } else if (group_type == MEDIA_GROUP_FOLDER) {
+               break;
+
+       case MEDIA_GROUP_FOLDER:
 #ifdef _USE_TVPD_MODE
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
+               if (_filter && STRING_VALID(_filter->storage_id))
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
 #else
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
+               if (_filter && STRING_VALID(_filter->storage_id))
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
 #endif
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
-       } else if (group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID) {
+               break;
+
+       case MEDIA_GROUP_TAG_BY_MEDIA_ID:
                snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
-       } else if (group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID) {
+               break;
+
+       case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
 #ifdef _USE_TVPD_MODE
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
+               if (_filter && STRING_VALID(_filter->storage_id))
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
 #else
-               tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
+               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
 #endif
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
-       } else if (group_type == MEDIA_GROUP_STORAGE) {
+               break;
+
+       case MEDIA_GROUP_STORAGE:
 #ifdef _USE_TVPD_MODE
-               tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
+               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
 #else
-               tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
+               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
 #endif
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
-       } else if (group_type == MEDIA_GROUP_FACE_BY_MEDIA_ID) {
+               break;
+
+       case MEDIA_GROUP_FACE_BY_MEDIA_ID:
 #ifdef _USE_TVPD_MODE
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
+               if (_filter && STRING_VALID(_filter->storage_id))
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
 #else
-               tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
+               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
 #endif
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+               break;
+
 #ifdef _USE_TVPD_MODE
-       } else if (group_type == MEDIA_GROUP_PVR) {
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+       case MEDIA_GROUP_PVR:
+               if (_filter && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_BY_STORAGE_ID, _filter->storage_id);
                else
-                       SAFE_STRLCAT(select_query, SELECT_PVR_COUNT, sizeof(select_query));
-       } else if (group_type == MEDIA_GROUP_UHD) {
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       SAFE_STRLCPY(select_query, SELECT_PVR_COUNT, sizeof(select_query));
+               break;
+
+       case MEDIA_GROUP_UHD:
+               if (_filter && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_BY_STORAGE_ID, _filter->storage_id);
                else
-                       SAFE_STRLCAT(select_query, SELECT_UHD_COUNT, sizeof(select_query));
+                       SAFE_STRLCPY(select_query, SELECT_UHD_COUNT, sizeof(select_query));
+               break;
 #endif
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+       default:
+               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);
-       if (ret != MEDIA_CONTENT_ERROR_NONE) {
-               if (tmp_query != NULL)
-                       SQLITE3_SAFE_FREE(tmp_query);
-               return ret;
-       }
-
-       if (group_type == MEDIA_GROUP_NONE) {
-               SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
-               if (STRING_VALID(condition_query)) {
-                       SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
-                       SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
-               }
-               if (STRING_VALID(option_query))
-                       SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
-
-               if (!is_simple)
-                       SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-               SAFE_FREE(condition_query);
-               SAFE_FREE(option_query);
+       if (need_bracket) {
+               tmp_option = g_strconcat(option_query, ")", NULL);
+               g_free(option_query);
+               option_query = tmp_option;
        }
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
-       if (tmp_query != NULL)
-               SQLITE3_SAFE_FREE(tmp_query);
        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);
@@ -1183,59 +1199,66 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb
 
        memset(select_query, 0x00, sizeof(select_query));
 
+       switch (group_type) {
+       case MEDIA_GROUP_ALBUM:
 #ifdef _USE_TVPD_MODE
-       if (group_type == MEDIA_GROUP_ALBUM) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
-       } else if (group_type == MEDIA_GROUP_PLAYLIST) {
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
-               else
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
-       } else if (group_type == MEDIA_GROUP_TAG) {
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
-               else
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
 #else
-       if (group_type == MEDIA_GROUP_ALBUM) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
-       } else if (group_type == MEDIA_GROUP_PLAYLIST) {
+#endif
+               break;
+
+       case MEDIA_GROUP_PLAYLIST:
+#ifdef _USE_TVPD_MODE
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, _filter->storage_id, group_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, DB_VIEW_MEDIA, group_id);
+#else
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
-       } else if (group_type == MEDIA_GROUP_TAG) {
+#endif
+               break;
+
+       case MEDIA_GROUP_TAG:
+#ifdef _USE_TVPD_MODE
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, _filter->storage_id, group_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, DB_VIEW_MEDIA, group_id);
+#else
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+#endif
+               break;
+
+       default:
+               content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
-#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;
                }
@@ -1265,50 +1288,58 @@ int _media_db_get_group_item(const char *group_name, filter_h filter, media_info
        filter_s *_filter = (filter_s *)filter;
 
        memset(select_query, 0x00, sizeof(select_query));
+
+       switch (group_type) {
+       case MEDIA_GROUP_NONE:
 #ifdef _USE_TVPD_MODE
-       if (group_type == MEDIA_GROUP_NONE) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, DB_VIEW_MEDIA);
-       } else if (group_type == MEDIA_GROUP_FOLDER) {
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
-               else
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
-       } else if (group_type == MEDIA_GROUP_STORAGE) {
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
 #else
-       if (group_type == MEDIA_GROUP_NONE) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
-       } else if (group_type == MEDIA_GROUP_FOLDER) {
+#endif
+               break;
+
+       case MEDIA_GROUP_FOLDER:
+#ifdef _USE_TVPD_MODE
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, _filter->storage_id, group_name);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
+#else
                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
-       } else if (group_type == MEDIA_GROUP_STORAGE) {
+#endif
+               break;
+
+       case MEDIA_GROUP_STORAGE:
+#ifdef _USE_TVPD_MODE
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name, group_name);
+#else
                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
-       } else {
-               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+#endif
+               break;
+
+       default:
+               content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
-#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;
                }
@@ -1353,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;
        }
 
@@ -1370,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;
        }
 
@@ -1379,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;
                }
@@ -1410,7 +1441,7 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        int ret = MEDIA_CONTENT_ERROR_NONE;
        sqlite3_stmt *stmt = NULL;
        char select_query[MAX_QUERY_SIZE] = {0, };
-       char *tmp_query = NULL;
+       char *tmp_option = NULL;
        char *condition_query = NULL;
        char *option_query = NULL;
        filter_s *_filter = (filter_s *)filter;
@@ -1420,11 +1451,9 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
                if (group_name != NULL) {
                        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                               tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
                        else
-                               tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
-
-                       SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+                               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
                } else {
                        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
@@ -1434,11 +1463,9 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        } else if (group < MEDIA_UHD_GROUP_CONTENT_TITLE) {/*pvr content*/
                if (group_name != NULL) {
                        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                               tmp_query = sqlite3_mprintf(SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
                        else
-                               tmp_query = sqlite3_mprintf(SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
-
-                       SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+                               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
                } else {
                        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                                snprintf(select_query, sizeof(select_query), SELECT_PVR_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
@@ -1448,11 +1475,9 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        } else {/*uhd content*/
                if (group_name != NULL) {
                        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                               tmp_query = sqlite3_mprintf(SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
                        else
-                               tmp_query = sqlite3_mprintf(SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
-
-                       SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+                               sqlite3_snprintf(sizeof(select_query), select_query, SELECT_UHD_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
                } else {
                        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                                snprintf(select_query, sizeof(select_query), SELECT_UHD_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
@@ -1462,13 +1487,10 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        }
 #else
        if (group_name != NULL) {
-               if ((_filter != NULL) && STRING_VALID(_filter->storage_id)) {
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
-                       SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
-               } else {
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
-                       SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
-               }
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
+               else
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
        } else {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
@@ -1477,30 +1499,21 @@ 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);
-       if (ret != MEDIA_CONTENT_ERROR_NONE) {
-               if (tmp_query != NULL)
-                       SQLITE3_SAFE_FREE(tmp_query);
-               return ret;
-       }
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
-       if (STRING_VALID(condition_query)) {
-               SAFE_STRLCAT(select_query, QUERY_KEYWORD_AND, sizeof(select_query));
-               SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
+       /* If 'filter' is not NULL, 'option_query' must be created. */
+       if (option_query) {
+               tmp_option = g_strconcat(option_query, ")", NULL);
+               g_free(option_query);
+               option_query = tmp_option;
+       } else {
+               SAFE_STRLCAT(select_query, ")", sizeof(select_query));
        }
-       if (STRING_VALID(option_query))
-               SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
-       SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
-
-       SAFE_FREE(condition_query);
-       SAFE_FREE(option_query);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
-       if (tmp_query != NULL)
-               SQLITE3_SAFE_FREE(tmp_query);
        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);
@@ -1514,7 +1527,6 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
        char select_query[MAX_QUERY_SIZE] = {0, };
-       char *tmp_query = NULL;
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
@@ -1524,11 +1536,9 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
 #ifdef _USE_TVPD_MODE
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
-
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
        } else {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
@@ -1538,11 +1548,9 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
 #else
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
-
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
        } else {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
@@ -1551,23 +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);
-       if (ret != MEDIA_CONTENT_ERROR_NONE) {
-               if (tmp_query != NULL)
-                       SQLITE3_SAFE_FREE(tmp_query);
-               return ret;
-       }
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
-       if (tmp_query != NULL)
-               SQLITE3_SAFE_FREE(tmp_query);
        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;
                }
@@ -1590,31 +1592,23 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
 int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
-       char select_query[DEFAULT_QUERY_SIZE] = {0, };
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
 
-       memset(select_query, 0x00, sizeof(select_query));
-
-       if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_LIST, sizeof(select_query))) {
-               media_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);
+       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;
                }
@@ -1646,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;
        }
 
@@ -1665,7 +1659,6 @@ int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
        char select_query[DEFAULT_QUERY_SIZE] = {0, };
-       char *tmp_query = NULL;
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
@@ -1675,11 +1668,9 @@ int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_
 
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       tmp_query = sqlite3_mprintf(SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group), group_name);
                else
-                       tmp_query = sqlite3_mprintf(SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
-
-               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+                       sqlite3_snprintf(sizeof(select_query), select_query, SELECT_PVR_FROM_GROUP, __media_db_get_group_name(group), group_name);
        } else {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL_BY_STORAGE_ID, _filter->storage_id, __media_db_get_group_name(group));
@@ -1688,23 +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);
-       if (ret != MEDIA_CONTENT_ERROR_NONE) {
-               if (tmp_query != NULL)
-                       sqlite3_free(tmp_query);
-               return ret;
-       }
+       content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
-       if (tmp_query != NULL)
-               sqlite3_free(tmp_query);
        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;
                }
@@ -1908,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;
                }
@@ -2007,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;
                }