X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fmedia_uhd.c;h=b9d78588661ad2419d1895115cca9f42509b0034;hb=d73fc79282be88e173519f060ca9cabbc4c9724c;hp=a7b79ecfff1f8b8a43200f02d01b0b45bef162e2;hpb=2f850ceaea8ac5f47304f756cc23c5abebe85389;p=platform%2Fcore%2Fapi%2Fmedia-content.git

diff --git a/src/media_uhd.c b/src/media_uhd.c
index a7b79ec..b9d7858 100755
--- a/src/media_uhd.c
+++ b/src/media_uhd.c
@@ -13,151 +13,68 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifdef _USE_TV_PROFILE
+#ifdef _USE_TVPD_MODE
 #include <media_info_private.h>
 #include <media_util_private.h>
 #include <media_uhd.h>
 
 int media_uhd_get_media_count_from_db(filter_h filter, int *media_count)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
+	content_retip_if_fail(media_count);
 
-	if (media_count) {
-		ret = _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
-
-	return ret;
+	return _media_db_get_group_item_count(NULL, filter, MEDIA_GROUP_UHD, media_count);
 }
 
 int media_uhd_foreach_media_from_db(filter_h filter, media_uhd_cb callback, void *user_data)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
-
-	if (callback != NULL) {
-		ret = _media_db_get_uhd(filter, callback, user_data);
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(callback);
 
-	return ret;
+	return _media_db_get_uhd(filter, callback, user_data);
 }
 
 int media_uhd_destroy(media_uhd_h uhd)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
-	if (_uhd) {
-		SAFE_FREE(_uhd->media_id);
-		SAFE_FREE(_uhd->storage_id);
-		SAFE_FREE(_uhd->path);
-		SAFE_FREE(_uhd->content_id);
-		SAFE_FREE(_uhd->content_title);
-		SAFE_FREE(_uhd->file_name);
-		SAFE_FREE(_uhd->release_date);
-		SAFE_FREE(_uhd);
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
 
-	return ret;
+	content_retip_if_fail(uhd);
+
+	g_free(_uhd->media_id);
+	g_free(_uhd->storage_id);
+	g_free(_uhd->path);
+	g_free(_uhd->content_id);
+	g_free(_uhd->content_title);
+	g_free(_uhd->file_name);
+	g_free(_uhd->release_date);
+	g_free(_uhd);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_clone(media_uhd_h *dst, media_uhd_h src)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_src = (media_uhd_s*)src;
 
-	if (_src != NULL) {
-		media_uhd_s *_dst = (media_uhd_s*)calloc(1, sizeof(media_uhd_s));
-		if (_dst == NULL) {
-			media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-			return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-		}
-
-		if (STRING_VALID(_src->media_id)) {
-			_dst->media_id = strdup(_src->media_id);
-			if (_dst->media_id == NULL) {
-				media_uhd_destroy((media_uhd_h)_dst);
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		if (STRING_VALID(_src->storage_id)) {
-			_dst->storage_id = strdup(_src->storage_id);
-			if (_dst->storage_id == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				media_uhd_destroy((media_uhd_h)_dst);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		if (STRING_VALID(_src->path)) {
-			_dst->path = strdup(_src->path);
-			if (_dst->path == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				media_uhd_destroy((media_uhd_h)_dst);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		if (STRING_VALID(_src->content_id)) {
-			_dst->content_id = strdup(_src->content_id);
-			if (_dst->content_id == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				media_uhd_destroy((media_uhd_h)_dst);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		if (STRING_VALID(_src->content_title)) {
-			_dst->content_title = strdup(_src->content_title);
-			if (_dst->content_title == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				media_uhd_destroy((media_uhd_h)_dst);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		if (STRING_VALID(_src->release_date)) {
-			_dst->release_date = strdup(_src->release_date);
-			if (_dst->release_date == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				media_uhd_destroy((media_uhd_h)_dst);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		if (STRING_VALID(_src->file_name)) {
-			_dst->file_name = strdup(_src->file_name);
-			if (_dst->file_name == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				media_uhd_destroy((media_uhd_h)_dst);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		}
-
-		_dst->size = _src->size;
-		_dst->modified_time = _src->modified_time;
-		_dst->played_position = _src->played_position;
-		_dst->sub_type = _src->sub_type;
-		_dst->played_count = _src->played_count;
-		*dst = (media_uhd_h)_dst;
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(dst);
+	content_retip_if_fail(src);
 
-	return ret;
+	media_uhd_s *_dst = g_new0(media_uhd_s, 1);
+
+	_dst->media_id = g_strdup(_src->media_id);
+	_dst->storage_id = g_strdup(_src->storage_id);
+	_dst->path = g_strdup(_src->path);
+	_dst->content_id = g_strdup(_src->content_id);
+	_dst->content_title = g_strdup(_src->content_title);
+	_dst->release_date = g_strdup(_src->release_date);
+	_dst->file_name = g_strdup(_src->file_name);
+	_dst->size = _src->size;
+	_dst->modified_time = _src->modified_time;
+	_dst->played_position = _src->played_position;
+	_dst->sub_type = _src->sub_type;
+	_dst->played_count = _src->played_count;
+
+	*dst = (media_uhd_h)_dst;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
@@ -166,34 +83,26 @@ int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
 	char *select_query = NULL;
 	sqlite3_stmt *stmt = NULL;
 
-	if (!STRING_VALID(media_id) || (uhd == NULL)) {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(STRING_VALID(media_id));
+	content_retip_if_fail(uhd);
 
 	select_query = sqlite3_mprintf(SELECT_UHD_FROM_UHD, media_id);
 
-	ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
-	sqlite3_free(select_query);
-	media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+	ret = _content_get_result(select_query, &stmt);
+	SQLITE3_SAFE_FREE(select_query);
+	content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
 	media_uhd_s *_uhd = NULL;
 
-	while (sqlite3_step(stmt) == SQLITE_ROW) {
-		if (_uhd)
-			media_uhd_destroy((media_uhd_h)_uhd);
-
-		_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);
-			SQLITE3_FINALIZE(stmt);
-			return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-		}
+	if (sqlite3_step(stmt) == SQLITE_ROW) {
+		_uhd = g_new0(media_uhd_s, 1);
 
 		_media_uhd_item_get_detail(stmt, (media_uhd_h)_uhd);
 
 		*uhd = (media_uhd_h)_uhd;
+	} else {
+		content_error("Nonexistent media id[%s]", media_id);
+		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 	}
 
 	SQLITE3_FINALIZE(stmt);
@@ -203,342 +112,207 @@ int media_uhd_get_uhd_from_db(const char *media_id, media_uhd_h *uhd)
 
 int media_uhd_get_media_id(media_uhd_h uhd, char **media_id)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && media_id) {
-		if (STRING_VALID(_uhd->media_id)) {
-			*media_id = strdup(_uhd->media_id);
-			if (*media_id == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*media_id = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(media_id);
 
-	return ret;
+	*media_id = g_strdup(_uhd->media_id);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_storage_id(media_uhd_h uhd, char **storage_id)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && storage_id) {
-		if (STRING_VALID(_uhd->storage_id)) {
-			*storage_id = strdup(_uhd->storage_id);
-			if (*storage_id == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*storage_id = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(storage_id);
 
-	return ret;
+	*storage_id = g_strdup(_uhd->storage_id);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_path(media_uhd_h uhd, char **path)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && path) {
-		if (STRING_VALID(_uhd->path)) {
-			*path = strdup(_uhd->path);
-			if (*path == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*path = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(path);
 
-	return ret;
+	*path = g_strdup(_uhd->path);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_size(media_uhd_h uhd, unsigned long long *size)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && size) {
-		*size = _uhd->size;
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(size);
 
-	return ret;
+	*size = _uhd->size;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_content_id(media_uhd_h uhd, char **content_id)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && content_id) {
-		if (STRING_VALID(_uhd->content_id)) {
-			*content_id = strdup(_uhd->content_id);
-			if (*content_id == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*content_id = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(content_id);
 
-	return ret;
+	*content_id = g_strdup(_uhd->content_id);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_content_title(media_uhd_h uhd, char **content_title)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && content_title) {
-		if (STRING_VALID(_uhd->content_title)) {
-			*content_title = strdup(_uhd->content_title);
-			if (*content_title == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*content_title = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(content_title);
 
-	return ret;
+	*content_title = g_strdup(_uhd->content_title);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_file_name(media_uhd_h uhd, char **file_name)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && file_name) {
-		if (STRING_VALID(_uhd->file_name)) {
-			*file_name = strdup(_uhd->file_name);
-			if (*file_name == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*file_name = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(file_name);
 
-	return ret;
+	*file_name = g_strdup(_uhd->file_name);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_release_date(media_uhd_h uhd, char **release_date)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && release_date) {
-		if (STRING_VALID(_uhd->release_date)) {
-			*release_date = strdup(_uhd->release_date);
-			if (*release_date == NULL) {
-				media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-				return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-			}
-		} else {
-			*release_date = NULL;
-		}
-
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(release_date);
 
-	return ret;
+	*release_date = g_strdup(_uhd->release_date);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_modified_time(media_uhd_h uhd, time_t *modified_time)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd && modified_time) {
-		*modified_time = _uhd->modified_time;
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(modified_time);
 
-	return ret;
+	*modified_time = _uhd->modified_time;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_played_position(media_uhd_h uhd, int *played_position)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd) {
-		*played_position = _uhd->played_position;
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(played_position);
 
-	return ret;
+	*played_position = _uhd->played_position;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_sub_type(media_uhd_h uhd, int *sub_type)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd) {
-		*sub_type = _uhd->sub_type;
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(sub_type);
 
-	return ret;
+	*sub_type = _uhd->sub_type;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_get_played_count(media_uhd_h uhd, int *played_count)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd) {
-		*played_count = _uhd->played_count;
-		ret = MEDIA_CONTENT_ERROR_NONE;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(played_count);
 
-	return ret;
+	*played_count = _uhd->played_count;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_played_position(media_uhd_h uhd, int played_position)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if ((_uhd != NULL) && (played_position >= 0)) {
-		_uhd->played_position = played_position;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(played_position);
 
-	return ret;
+	_uhd->played_position = played_position;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_content_title(media_uhd_h uhd, const char *content_title)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd != NULL && STRING_VALID(content_title)) {
-		SAFE_FREE(_uhd->content_title);
-		_uhd->content_title = strdup(content_title);
-		if (_uhd->content_title == NULL) {
-			media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-			return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-		}
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(STRING_VALID(content_title));
 
-	return ret;
+	g_free(_uhd->content_title);
+	_uhd->content_title = g_strdup(content_title);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_release_date(media_uhd_h uhd, const char *release_date)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd != NULL && STRING_VALID(release_date)) {
-		SAFE_FREE(_uhd->release_date);
-		_uhd->release_date = strdup(release_date);
-		if (_uhd->release_date == NULL) {
-			media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
-			return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
-		}
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(STRING_VALID(release_date));
 
-	return ret;
+	g_free(_uhd->release_date);
+	_uhd->release_date = g_strdup(release_date);
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_sub_type(media_uhd_h uhd, int sub_type)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if ((_uhd != NULL) && (sub_type >= 0)) {
-		_uhd->sub_type = sub_type;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(sub_type >= 0);
 
-	return ret;
+	_uhd->sub_type = sub_type;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_set_played_count(media_uhd_h uhd, int played_count)
 {
-	int ret = MEDIA_CONTENT_ERROR_NONE;
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 
-	if (_uhd != NULL) {
-		_uhd->played_count = played_count;
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	content_retip_if_fail(uhd);
 
-	return ret;
+	_uhd->played_count = played_count;
+
+	return MEDIA_CONTENT_ERROR_NONE;
 }
 
 int media_uhd_update_to_db(media_uhd_h uhd)
@@ -547,15 +321,14 @@ int media_uhd_update_to_db(media_uhd_h uhd)
 	media_uhd_s *_uhd = (media_uhd_s*)uhd;
 	char *update_query = NULL;
 
-	if (_uhd != NULL && STRING_VALID(_uhd->media_id) && STRING_VALID(_uhd->path)) {
-		update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->release_date, _uhd->played_position, _uhd->sub_type, _uhd->played_count, _uhd->media_id);
+	content_retip_if_fail(uhd);
+	content_retip_if_fail(STRING_VALID(_uhd->media_id));
+	content_retip_if_fail(STRING_VALID(_uhd->path));
 
-		ret = _content_query_sql(update_query);
-		sqlite3_free(update_query);
-	} else {
-		media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-		ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-	}
+	update_query = sqlite3_mprintf(UPDATE_UHD_META_FROM_UHD, _uhd->content_title, _uhd->release_date, _uhd->played_position, _uhd->sub_type, _uhd->played_count, _uhd->media_id);
+
+	ret = _content_query_sql(update_query);
+	sqlite3_free(update_query);
 
 	return ret;
 }