2.0_beta

diff --git a/TC/testcase/utc_metadata_extractor.c b/TC/testcase/utc_metadata_extractor.c
index f157dab..9fd642b 100755 (executable)
--- a/TC/testcase/utc_metadata_extractor.c
+++ b/TC/testcase/utc_metadata_extractor.c
@@ -43,6 +43,8 @@ static void utc_metadata_extractor_get_artwork_n(void);
 static void utc_metadata_extractor_get_artwork_p(void);
 static void utc_metadata_extractor_get_frame_n(void);
 static void utc_metadata_extractor_get_frame_p(void);
+static void utc_metadata_extractor_get_frame_at_time_n(void);
+static void utc_metadata_extractor_get_frame_at_time_p(void);
 static void utc_metadata_extractor_get_synclyrics_n(void);
 static void utc_metadata_extractor_get_synclyrics_p(void);
 
@@ -60,6 +62,8 @@ struct tet_testlist tet_testlist[] = {
        { utc_metadata_extractor_get_frame_p, 2 },
        { utc_metadata_extractor_get_synclyrics_n, 2 },
        { utc_metadata_extractor_get_synclyrics_p, 2 },
+       { utc_metadata_extractor_get_frame_at_time_n, 2 },
+       { utc_metadata_extractor_get_frame_at_time_p, 2 },
        { utc_metadata_extractor_destroy_n, 3 },
        { utc_metadata_extractor_destroy_p, 3 },
        { NULL, 0 },
@@ -132,7 +136,7 @@ static void utc_metadata_extractor_set_path_p(void)
 static void utc_metadata_extractor_get_metadata_n(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       char * value = NULL;
+       char *value = NULL;
 
        ret = metadata_extractor_get_metadata(metadata, -1, &value);
 
@@ -145,7 +149,7 @@ static void utc_metadata_extractor_get_metadata_n(void)
 static void utc_metadata_extractor_get_metadata_p(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       char * value = NULL;
+       char *value = NULL;
 
        ret = metadata_extractor_get_metadata(metadata, METADATA_TITLE, &value);
        if(value)
@@ -160,8 +164,8 @@ static void utc_metadata_extractor_get_metadata_p(void)
 static void utc_metadata_extractor_get_artwork_n(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       void * artwork = NULL;
-       char * artwork_mime = NULL;
+       void *artwork = NULL;
+       char *artwork_mime = NULL;
        int artwork_size = 0;
 
        ret = metadata_extractor_get_artwork(NULL, &artwork, &artwork_size, &artwork_mime);
@@ -175,8 +179,8 @@ static void utc_metadata_extractor_get_artwork_n(void)
 static void utc_metadata_extractor_get_artwork_p(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       void * artwork = NULL;
-       char * artwork_mime = NULL;
+       void *artwork = NULL;
+       char *artwork_mime = NULL;
        int artwork_size = 0;
 
        ret = metadata_extractor_get_artwork(metadata, &artwork, &artwork_size, &artwork_mime);
@@ -194,7 +198,7 @@ static void utc_metadata_extractor_get_artwork_p(void)
 static void utc_metadata_extractor_get_frame_n(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       void * frame = NULL;
+       void *frame = NULL;
        int frame_size = 0;
 
        ret = metadata_extractor_get_frame(NULL, &frame, &frame_size);
@@ -208,7 +212,7 @@ static void utc_metadata_extractor_get_frame_n(void)
 static void utc_metadata_extractor_get_frame_p(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       void * frame = NULL;
+       void *frame = NULL;
        int frame_size = 0;
 
        ret = metadata_extractor_get_frame(metadata, &frame, &frame_size);
@@ -219,13 +223,43 @@ static void utc_metadata_extractor_get_frame_p(void)
 }
 
 /**
+ * @brief Negative test case of metadata_extractor_get_frame_at_time()
+ */
+static void utc_metadata_extractor_get_frame_at_time_n(void)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       void *frame = NULL;
+       int frame_size = 0;
+
+       ret = metadata_extractor_get_frame_at_time(NULL, 0, true, &frame, &frame_size);
+
+       dts_check_eq("utc_metadata_extractor_get_frame_at_time_n", ret, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Must return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER in case of invalid parameter");
+}
+
+/**
+ * @brief Positive test case of metadata_extractor_get_frame_at_time()
+ */
+static void utc_metadata_extractor_get_frame_at_time_p(void)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       void *frame = NULL;
+       int frame_size = 0;
+
+       ret = metadata_extractor_get_frame_at_time(metadata, 22500, true, &frame, &frame_size);
+       if(frame)
+               free(frame);
+
+       dts_check_eq("utc_metadata_extractor_get_frame_at_time_p", ret, METADATA_EXTRACTOR_ERROR_NONE, "Failed to get frame");
+}
+
+/**
  * @brief Negative test case of metadata_extractor_get_synclyrics()
  */
 static void utc_metadata_extractor_get_synclyrics_n(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       unsigned long  time_info = 0;
-       char * lyrics = NULL;
+       unsigned long time_info = 0;
+       char *lyrics = NULL;
 
        ret = metadata_extractor_get_synclyrics(NULL, 1, &time_info, &lyrics);
 
@@ -238,8 +272,8 @@ static void utc_metadata_extractor_get_synclyrics_n(void)
 static void utc_metadata_extractor_get_synclyrics_p(void)
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
-       unsigned long  time_info = 0;
-       char * lyrics = NULL;
+       unsigned long time_info = 0;
+       char *lyrics = NULL;
 
        ret = metadata_extractor_get_synclyrics(metadata, 1, &time_info, &lyrics);
        if(lyrics)

diff --git a/debian/changelog b/debian/changelog
index fe30465..93a20f1 100755 (executable)
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,7 +1,39 @@
+capi-media-metadata-extractor (0.1.0-4) unstable; urgency=low
+
+  * add metadata_extractor_get_frame_at_time
+  * Git: slp/api/metadata-extractor
+  * Tag: capi-media-metadata-extractor_0.1.0-4
+
+ -- Haejeong Kim <backto.kim@samsung.com>  Tue, 12 Jun 2012 16:48:26 +0900
+
+capi-media-metadata-extractor (0.1.0-3) unstable; urgency=low
+
+  * bug fix of release handle
+  * Git: slp/api/metadata-extractor
+  * Tag: capi-media-metadata-extractor_0.1.0-3
+
+ -- Haejeong Kim <backto.kim@samsung.com>  Fri, 30 Mar 2012 11:49:56 +0900
+
+capi-media-metadata-extractor (0.1.0-2) unstable; urgency=low
+
+  * bug fix of mistype 
+  * Git: slp/api/metadata-extractor
+  * Tag: capi-media-metadata-extractor_0.1.0-2
+
+ -- Haejeong Kim <backto.kim@samsung.com>  Tue, 20 Mar 2012 11:16:30 +0900
+
+capi-media-metadata-extractor (0.1.0-1) unstable; urgency=low
+
+  * bug fix of pkg dependency
+  * Git: slp/api/metadata-extractor
+  * Tag: capi-media-metadata-extractor_0.1.0-1
+
+ -- Haejeong Kim <backto.kim@samsung.com>  Fri, 02 Mar 2012 10:16:46 +0900
+
 capi-media-metadata-extractor (0.1.0-0) unstable; urgency=low
 
   * Initial release
   * Git: slp/api/metadata-extractor
   * Tag: capi-media-metadata-extractor_0.1.0-0
 
- -- Haejeong Kim <backto.kim@samsung.com>  Mon, 19 Mar 2012 12:10:16 +0900
+ -- Haejeong Kim <backto.kim@samsung.com>  Wed, 22 Feb 2012 18:10:16 +0900

diff --git a/include/metadata_extractor.h b/include/metadata_extractor.h
index 0a858c8..53a73c8 100755 (executable)
--- a/include/metadata_extractor.h
+++ b/include/metadata_extractor.h
@@ -1,172 +1,194 @@
-/*\r
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*/\r
-\r
-#ifndef __TIZEN_MEDIA_METADATA_EXTRACTOR_H__\r
-#define __TIZEN_MEDIA_METADATA_EXTRACTOR_H__\r
-\r
-\r
-#include <tizen.h>\r
-#include <metadata_extractor_type.h>\r
-\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif /* __cplusplus */\r
-\r
-/**\r
- * @addtogroup CAPI_METADATA_EXTRACTOR_MODULE\r
- * @{\r
- *\r
- * @file metadata_extractor.h\r
- * @brief This file contains the multimedia content metadata extractor API and related structure and enumeration. \n\r
- *        Description of metadata: duration, bitrate, album, artist, author, genre and description etc. \n\r
- */\r
-\r
-\r
-/**\r
- * @brief Create metadata\r
- *\r
- * @remarks @a metadata must be released metadata_extractor_destroy() by you\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available\r
- * @see metadata_extractor_destroy()\r
- */\r
-int metadata_extractor_create(metadata_extractor_h* metadata);\r
-\r
-\r
-/**\r
- * @brief Set file path to extract\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @param [in] path path to extract metadata\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_FILE_EXISTS File not exist\r
- * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail\r
- * @pre Create metadata handle by calling metadata_extractor_create()\r
- * @see metadata_extractor_create(), metadata_extractor_destroy()\r
- */\r
-int metadata_extractor_set_path(metadata_extractor_h metadata, const char* path);\r
-\r
-\r
-/**\r
- * @brief Destroy metadata\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail\r
- * @pre Create metadata handle by calling metadata_extractor_create()\r
- * @see metadata_extractor_create()\r
- */\r
-int metadata_extractor_destroy(metadata_extractor_h metadata);\r
-\r
-\r
-/**\r
- * @brief Get metadata\r
- *\r
- * @remarks @a value must be released with @c free() by you\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @param [in] attribute key attribute name to get\r
- * @param [out] value The value of the attribute\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available\r
- * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail\r
- * @pre Set path to extract by calling metadata_extractor_set_path()\r
- * @see metadata_extractor_create(), metadata_extractor_destroy()\r
- */\r
-int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extractor_attr_e attribute, char ** value);\r
-\r
-\r
-/**\r
- * @brief Get artwork image in media file\r
- *\r
- * @remarks @a artwork and @a artwork_mime must be released with @c free() by you\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @param [out] artwork encoded artwork image\r
- * @param [out] size encoded artwork size\r
- * @param [out] mime_type mime type of artwork\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available\r
- * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail\r
- * @pre Set path to extract by calling metadata_extractor_set_path()\r
- * @see metadata_extractor_create(), metadata_extractor_destroy()\r
- */\r
-int metadata_extractor_get_artwork(metadata_extractor_h metadata, void ** artwork, int * size, char ** mime_type);\r
-\r
-\r
-/**\r
- * @brief Get frame of video media file\r
- *\r
- * @remarks @a frame must be released with @c free() by you\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @param [out] frame raw frame data\r
- * @param [out] size The frame data size\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available\r
- * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail\r
- * @pre Set path to extract by calling metadata_extractor_set_path()\r
- * @see metadata_extractor_create(), metadata_extractor_destroy()\r
- */\r
-int metadata_extractor_get_frame(metadata_extractor_h metadata, void ** frame, int * size);\r
-\r
-\r
-/**\r
- * @brief Get synclyric of media file\r
- *\r
- * @remarks @a lyrics must be released with @c free() by you\r
- *\r
- * @param [in] metadata The handle to metadata\r
- * @param [in] index Index of time/lyrics set\r
- * @param [out] time_info Time information of index\r
- * @param [out] lyrics Lyric of index\r
- * @return 0 on success, otherwise a negative error value\r
- * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful\r
- * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER  Invalid parameter\r
- * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail\r
- * @pre Set path to extract by calling metadata_extractor_set_path()\r
- * @pre Get time/lyrics set number by calling metadata_extractor_get_metadata(METADATA_SYNCLYRICS_NUM)\r
- * @see metadata_extractor_create(), metadata_extractor_destroy()\r
- */\r
-int metadata_extractor_get_synclyrics(metadata_extractor_h metadata, int index, unsigned long *time_stamp, char ** lyrics);\r
-\r
-/**\r
- * @}\r
- */\r
-\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif /* __cplusplus */\r
-\r
-#endif /* __TIZEN_MEDIA_METADATA_EXTRACTOR_H__ */\r
-\r
-\r
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __TIZEN_MEDIA_METADATA_EXTRACTOR_H__
+#define __TIZEN_MEDIA_METADATA_EXTRACTOR_H__
+
+
+#include <tizen.h>
+#include <metadata_extractor_type.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * @addtogroup CAPI_METADATA_EXTRACTOR_MODULE
+ * @{
+ *
+ * @file metadata_extractor.h
+ * @brief This file contains the multimedia content metadata extractor API and related structure and enumeration. \n
+ *        Description of metadata: duration, bitrate, album, artist, author, genre and description etc. \n
+ */
+
+
+/**
+ * @brief Create metadata
+ *
+ * @remarks @a metadata must be released metadata_extractor_destroy() by you
+ *
+ * @param [in] metadata The handle to metadata
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available
+ * @see metadata_extractor_destroy()
+ */
+int metadata_extractor_create(metadata_extractor_h *metadata);
+
+
+/**
+ * @brief Set file path to extract
+ *
+ * @param [in] metadata The handle to metadata
+ * @param [in] path path to extract metadata
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_FILE_EXISTS File not exist
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Create metadata handle by calling metadata_extractor_create()
+ * @see metadata_extractor_create(), metadata_extractor_destroy()
+ */
+int metadata_extractor_set_path(metadata_extractor_h metadata, const char *path);
+
+
+/**
+ * @brief Destroy metadata
+ *
+ * @param [in] metadata The handle to metadata
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Create metadata handle by calling metadata_extractor_create()
+ * @see metadata_extractor_create()
+ */
+int metadata_extractor_destroy(metadata_extractor_h metadata);
+
+
+/**
+ * @brief Get metadata
+ *
+ * @remarks @a value must be released with @c free() by you
+ *
+ * @param [in] metadata The handle to metadata
+ * @param [in] attribute key attribute name to get
+ * @param [out] value The value of the attribute
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Set path to extract by calling metadata_extractor_set_path()
+ * @see metadata_extractor_create(), metadata_extractor_destroy()
+ */
+int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extractor_attr_e attribute, char **value);
+
+
+/**
+ * @brief Get artwork image in media file
+ *
+ * @remarks @a artwork and @a artwork_mime must be released with @c free() by you
+ *
+ * @param [in] metadata The handle to metadata
+ * @param [out] artwork encoded artwork image
+ * @param [out] size encoded artwork size
+ * @param [out] mime_type mime type of artwork
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Set path to extract by calling metadata_extractor_set_path()
+ * @see metadata_extractor_create(), metadata_extractor_destroy()
+ */
+int metadata_extractor_get_artwork(metadata_extractor_h metadata, void **artwork, int *size, char **mime_type);
+
+
+/**
+ * @brief Get frame of video media file
+ *
+ * @remarks @a frame must be released with @c free() by you
+ *
+ * @param [in] metadata The handle to metadata
+ * @param [out] frame raw frame data in RGB888
+ * @param [out] size The frame data size
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Set path to extract by calling metadata_extractor_set_path()
+ * @see metadata_extractor_create(), metadata_extractor_destroy()
+ */
+int metadata_extractor_get_frame(metadata_extractor_h metadata, void **frame, int *size);
+
+
+/**
+ * @brief Get synclyric of media file
+ *
+ * @remarks @a lyrics must be released with @c free() by you
+ *
+ * @param [in] metadata The handle to metadata
+ * @param [in] index Index of time/lyrics set
+ * @param [out] time_info Time information of index
+ * @param [out] lyrics Lyric of index
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Set path to extract by calling metadata_extractor_set_path()
+ * @pre Get time/lyrics set number by calling metadata_extractor_get_metadata(METADATA_SYNCLYRICS_NUM)
+ * @see metadata_extractor_create(), metadata_extractor_destroy()
+ */
+int metadata_extractor_get_synclyrics(metadata_extractor_h metadata, int index, unsigned long *time_stamp, char **lyrics);
+
+/**
+ * @brief Get a frame of video media
+ *
+ * @remarks @a frame must be released with @c free() by you
+ *
+ * @param [in] metadata The handle to metadata
+ * @param [in] timestamp The timestamp in milliseconds
+ * @param [in] is_accurate @a true, user can get an accurated frame for given the timestamp.\n
+ * @a false, user can only get the nearest i-frame of video rapidly.
+ * @param [out] frame raw frame data in RGB888
+ * @param [out] size The frame data size
+ * @return 0 on success, otherwise a negative error value
+ * @retval #METADATA_EXTRACTOR_ERROR_NONE Successful
+ * @retval #METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY Not enough memory is available
+ * @retval #METADATA_EXTRACTOR_ERROR_OPERATION_FAILED Internal Operation Fail
+ * @pre Set path to extract by calling metadata_extractor_set_path()
+ * @see metadata_extractor_create(), metadata_extractor_destroy()
+ */
+
+int metadata_extractor_get_frame_at_time(metadata_extractor_h metadata, unsigned long timestamp, bool is_accurate, void **frame, int *size);
+
+/**
+ * @}
+ */
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __TIZEN_MEDIA_METADATA_EXTRACTOR_H__ */
+
+

diff --git a/include/metadata_extractor_private.h b/include/metadata_extractor_private.h
index 5027b17..267bb38 100755 (executable)
--- a/include/metadata_extractor_private.h
+++ b/include/metadata_extractor_private.h
@@ -18,7 +18,7 @@
 #ifndef __TIZEN_MEDIA_METADATA_EXTRACTOR_PRIVATE_H__
 #define __TIZEN_MEDIA_METADATA_EXTRACTOR_PRIVATE_H__
 
-
+#include <stdbool.h>
 #include <mm_types.h>
 
 
@@ -29,6 +29,9 @@ extern "C" {
 
 typedef struct
 {
+       char *path;
+       bool extract_meta;
+
        int audio_track_cnt;
        int video_track_cnt;
 

diff --git a/include/metadata_extractor_type.h b/include/metadata_extractor_type.h
index b3d8987..703a04c 100755 (executable)
--- a/include/metadata_extractor_type.h
+++ b/include/metadata_extractor_type.h
@@ -1,103 +1,103 @@
-/*\r
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*/\r
-\r
-\r
-\r
-#ifndef __TIZEN_MEDIA_METADATA_EXTRACTOR_TYPE_H__\r
-#define __TIZEN_MEDIA_METADATA_EXTRACTOR_TYPE_H__\r
-\r
-#include <tizen.h>\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif /* __cplusplus */\r
-\r
-\r
-/**\r
-* @addtogroup CAPI_METADATA_EXTRACTOR_MODULE\r
-* @{\r
-*/\r
-\r
-/** Content Error Class */\r
-#define METADATA_EXTRACTOR_ERROR_CLASS                         TIZEN_ERROR_MULTIMEDIA_CLASS | 0x80\r
-\r
-/**\r
- * @ingroup CAPI_METADATA_EXTRACTOR_MODULE\r
- * @brief The enumerations of metadata extractor error\r
- */\r
-typedef enum\r
-{\r
-    METADATA_EXTRACTOR_ERROR_NONE                                      = TIZEN_ERROR_NONE,                             /**< Successful */\r
-    METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER,        /**< Invalid parameter */\r
-    METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY             = TIZEN_ERROR_OUT_OF_MEMORY,            /**< Out of memory */\r
-    METADATA_EXTRACTOR_ERROR_FILE_EXISTS                               = TIZEN_ERROR_FILE_EXISTS,                      /**< File not exist */\r
-    METADATA_EXTRACTOR_ERROR_OPERATION_FAILED          = METADATA_EXTRACTOR_ERROR_CLASS |0x01, /** < Invalid internal operation*/\r
-} metadata_extractor_error_e;\r
-\r
-\r
-/**\r
- * @ingroup CAPI_METADATA_EXTRACTOR_MODULE\r
- * @brief The enumerations of attribute\r
- */\r
-typedef enum\r
-{\r
-       METADATA_DURATION       = 0,                    /**< Duration */\r
-       METADATA_VIDEO_BITRATE,                 /**< Video Bitrate */\r
-       METADATA_VIDEO_FPS,                             /**< Video FPS */\r
-       METADATA_VIDEO_WIDTH,                   /**< Video Width*/\r
-       METADATA_VIDEO_HEIGHT,                  /**< Video Height*/\r
-       METADATA_HAS_VIDEO,                             /**< Video stream count */\r
-       METADATA_AUDIO_BITRATE,                 /**< Audio Bitrate*/\r
-       METADATA_AUDIO_CHANNELS,                /**< Audio Channels*/\r
-       METADATA_AUDIO_SAMPLERATE,              /**< Audio Samplerate*/\r
-       METADATA_HAS_AUDIO,                             /**< Audio stream count */\r
-       METADATA_ARTIST,                                        /**< Artist*/\r
-       METADATA_TITLE,                                 /**< Title*/\r
-       METADATA_ALBUM,                                 /**< Album*/\r
-       METADATA_GENRE,                                 /**< Genre*/\r
-       METADATA_AUTHOR,                                        /**< Author*/\r
-       METADATA_COPYRIGHT,                             /**< Copyright*/\r
-       METADATA_DATE,                                  /**< Date*/\r
-       METADATA_DESCRIPTION,                           /**< Description*/\r
-       METADATA_TRACK_NUM,                             /**< Track number info*/\r
-       METADATA_CLASSIFICATION,                        /**< Classification*/\r
-       METADATA_RATING,                                        /**< Rating*/\r
-       METADATA_LONGITUDE,                             /**< Longitude*/\r
-       METADATA_LATITUDE,                              /**< Latitude*/\r
-       METADATA_ALTITUDE,                              /**< Altitude*/\r
-       METADATA_CONDUCTOR,                             /**< Conductor*/\r
-       METADATA_UNSYNCLYRICS,                  /**< Unsyncronized lyric*/\r
-       METADATA_SYNCLYRICS_NUM,                /**< Syncronized lyric (time/lyric set) number*/\r
-       METADATA_RECDATE,                               /**< Recording date*/\r
-} metadata_extractor_attr_e;\r
-\r
-\r
-/**\r
- * @ingroup CAPI_METADATA_EXTRACTOR_MODULE\r
- * @brief The handle of metadata extractor\r
- */\r
-typedef struct metadata_extractor_s* metadata_extractor_h;\r
-\r
-/**\r
- * @}\r
- */\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif /* __cplusplus */\r
-\r
-\r
-#endif /*__TIZEN_MEDIA_METADATA_EXTRACTOR_TYPE_H__*/\r
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#ifndef __TIZEN_MEDIA_METADATA_EXTRACTOR_TYPE_H__
+#define __TIZEN_MEDIA_METADATA_EXTRACTOR_TYPE_H__
+
+#include <tizen.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+* @addtogroup CAPI_METADATA_EXTRACTOR_MODULE
+* @{
+*/
+
+/** Content Error Class */
+#define METADATA_EXTRACTOR_ERROR_CLASS                         TIZEN_ERROR_MULTIMEDIA_CLASS | 0x80
+
+/**
+ * @ingroup CAPI_METADATA_EXTRACTOR_MODULE
+ * @brief The enumerations of metadata extractor error
+ */
+typedef enum
+{
+    METADATA_EXTRACTOR_ERROR_NONE                                      = TIZEN_ERROR_NONE,                             /**< Successful */
+    METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER,        /**< Invalid parameter */
+    METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY             = TIZEN_ERROR_OUT_OF_MEMORY,            /**< Out of memory */
+    METADATA_EXTRACTOR_ERROR_FILE_EXISTS                               = TIZEN_ERROR_FILE_EXISTS,                      /**< File not exist */
+    METADATA_EXTRACTOR_ERROR_OPERATION_FAILED          = METADATA_EXTRACTOR_ERROR_CLASS |0x01, /**< Invalid internal operation */
+} metadata_extractor_error_e;
+
+
+/**
+ * @ingroup CAPI_METADATA_EXTRACTOR_MODULE
+ * @brief The enumerations of attribute
+ */
+typedef enum
+{
+       METADATA_DURATION       = 0,                    /**< Duration */
+       METADATA_VIDEO_BITRATE,                 /**< Video Bitrate */
+       METADATA_VIDEO_FPS,                             /**< Video FPS */
+       METADATA_VIDEO_WIDTH,                   /**< Video Width*/
+       METADATA_VIDEO_HEIGHT,                  /**< Video Height*/
+       METADATA_HAS_VIDEO,                             /**< Video stream count */
+       METADATA_AUDIO_BITRATE,                 /**< Audio Bitrate*/
+       METADATA_AUDIO_CHANNELS,                /**< Audio Channels*/
+       METADATA_AUDIO_SAMPLERATE,              /**< Audio Samplerate*/
+       METADATA_HAS_AUDIO,                             /**< Audio stream count */
+       METADATA_ARTIST,                                        /**< Artist*/
+       METADATA_TITLE,                                 /**< Title*/
+       METADATA_ALBUM,                                 /**< Album*/
+       METADATA_GENRE,                                 /**< Genre*/
+       METADATA_AUTHOR,                                        /**< Author*/
+       METADATA_COPYRIGHT,                             /**< Copyright*/
+       METADATA_DATE,                                  /**< Date*/
+       METADATA_DESCRIPTION,                           /**< Description*/
+       METADATA_TRACK_NUM,                             /**< Track number info*/
+       METADATA_CLASSIFICATION,                        /**< Classification*/
+       METADATA_RATING,                                        /**< Rating*/
+       METADATA_LONGITUDE,                             /**< Longitude*/
+       METADATA_LATITUDE,                              /**< Latitude*/
+       METADATA_ALTITUDE,                              /**< Altitude*/
+       METADATA_CONDUCTOR,                             /**< Conductor*/
+       METADATA_UNSYNCLYRICS,                  /**< Unsyncronized lyric*/
+       METADATA_SYNCLYRICS_NUM,                /**< Syncronized lyric (time/lyric set) number*/
+       METADATA_RECDATE,                               /**< Recording date*/
+} metadata_extractor_attr_e;
+
+
+/**
+ * @ingroup CAPI_METADATA_EXTRACTOR_MODULE
+ * @brief The handle of metadata extractor
+ */
+typedef struct metadata_extractor_s* metadata_extractor_h;
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /*__TIZEN_MEDIA_METADATA_EXTRACTOR_TYPE_H__*/

diff --git a/packaging/capi-media-metadata-extractor.spec b/packaging/capi-media-metadata-extractor.spec
index 598b9ee..8fd0d7c 100755 (executable)
--- a/packaging/capi-media-metadata-extractor.spec
+++ b/packaging/capi-media-metadata-extractor.spec
@@ -1,16 +1,15 @@
+#sbs-git:slp/api/metadata-extractor capi-media-metadata-extractor 0.1.0 6b3c03f72f7fd67cdee06dbde70eb2e10335b57a
 Name:       capi-media-metadata-extractor
 Summary:    A media metadata extractor library in SLP C API
 Version: 0.1.0
-Release:    2
+Release:    4
 Group:      TO_BE/FILLED_IN
 License:    TO BE FILLED IN
 Source0:    %{name}-%{version}.tar.gz
 BuildRequires:  cmake
 BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(mm-fileinfo)
-BuildRequires:  pkgconfig(mm-player)
 BuildRequires:  pkgconfig(capi-base-common)
-BuildRequires:  pkgconfig(capi-media-sound-manager)
 Requires(post): /sbin/ldconfig
 Requires(postun): /sbin/ldconfig
 
@@ -20,6 +19,7 @@ A media metadata extractor  library in SLP C API
 %package devel
 Summary:  A media metadata extractor  library in SLP C API (Development)
 Group:    TO_BE/FILLED_IN
+Requires: %{name} = %{version}-%{release}
 
 %description devel
 A media metadata extractor  library in SLP C API
@@ -45,9 +45,9 @@ rm -rf %{buildroot}
 
 
 %files
+/usr/lib/libcapi-media-metadata-extractor.so
 
 %files devel
 /usr/include/media/*.h
-/usr/lib/libcapi-media-metadata-extractor.so
 /usr/lib/pkgconfig/capi-media-metadata-extractor.pc
 

diff --git a/src/metadata_extractor.c b/src/metadata_extractor.c
index b7eb3fb..68e7f02 100755 (executable)
--- a/src/metadata_extractor.c
+++ b/src/metadata_extractor.c
@@ -1,1334 +1,1437 @@
-/*\r
-* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
-*\r
-* Licensed under the Apache License, Version 2.0 (the "License");\r
-* you may not use this file except in compliance with the License.\r
-* You may obtain a copy of the License at\r
-*\r
-* http://www.apache.org/licenses/LICENSE-2.0\r
-*\r
-* Unless required by applicable law or agreed to in writing, software\r
-* distributed under the License is distributed on an "AS IS" BASIS,\r
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-* See the License for the specific language governing permissions and\r
-* limitations under the License.\r
-*/\r
-\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <string.h>\r
-#include <mm_file.h>\r
-#include <mm_error.h>\r
-#include <dlog.h>\r
-#include <metadata_extractor.h>\r
-#include <metadata_extractor_private.h>\r
-\r
-#define SAFE_FREE(src)      { if(src) {free(src); src = NULL;}}\r
-#define META_MAX_LEN   256\r
-\r
-#ifdef LOG_TAG\r
-#undef LOG_TAG\r
-#endif\r
-#define LOG_TAG "TIZEN_N_METADATAEXTRACTOR"\r
-\r
-\r
-static int __metadata_extractor_create_content_attrs(metadata_extractor_s* metadata, const char* path);\r
-static int __metadata_extractor_create_tag_attr(metadata_extractor_s* metadata, const char* path);\r
-static int __metadata_extractor_get_artwork(metadata_extractor_s* metadata, void ** artwork, int * artwork_size);\r
-static int __metadata_extractor_get_artwork_mime(metadata_extractor_s* metadata, char ** artwork_mime);\r
-static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s* metadata, void ** thumbnail, int * thumbnail_len);\r
-static int __metadata_extractor_get_duration(metadata_extractor_s* metadata, int * duration);\r
-static int __metadata_extractor_get_audio_bitrate(metadata_extractor_s* metadata, int * bitrate);\r
-static int __metadata_extractor_get_audio_channel(metadata_extractor_s* metadata, int * channel);\r
-static int __metadata_extractor_get_audio_samplerate(metadata_extractor_s* metadata, int * samplerate);\r
-static int __metadata_extractor_get_audio_track_count(metadata_extractor_s* metadata, int * track_cnt);\r
-static int __metadata_extractor_get_video_bitrate(metadata_extractor_s* metadata, int * bitrate);\r
-static int __metadata_extractor_get_video_FPS(metadata_extractor_s* metadata, int * fps);\r
-static int __metadata_extractor_get_video_width(metadata_extractor_s* metadata, int * width);\r
-static int __metadata_extractor_get_video_height(metadata_extractor_s* metadata, int * height);\r
-static int __metadata_extractor_get_video_track_count(metadata_extractor_s* metadata, int * track_cnt);\r
-static int __metadata_extractor_get_artist(metadata_extractor_s* metadata, char ** artist);\r
-static int __metadata_extractor_get_title(metadata_extractor_s* metadata, char ** title);\r
-static int __metadata_extractor_get_album(metadata_extractor_s* metadata, char ** album);\r
-static int __metadata_extractor_get_genre(metadata_extractor_s* metadata, char ** genre);\r
-static int __metadata_extractor_get_author(metadata_extractor_s* metadata, char ** author);\r
-static int __metadata_extractor_get_copyright(metadata_extractor_s* metadata, char ** copyright);\r
-static int __metadata_extractor_get_date(metadata_extractor_s* metadata, char ** date);\r
-static int __metadata_extractor_get_description(metadata_extractor_s* metadata, char ** description);\r
-static int __metadata_extractor_get_track_num(metadata_extractor_s* metadata, char ** track_num);\r
-static int __metadata_extractor_get_classification(metadata_extractor_s* metadata, char ** classification);\r
-static int __metadata_extractor_get_rating(metadata_extractor_s* metadata, char ** rating);\r
-static int __metadata_extractor_get_longitude(metadata_extractor_s* metadata, double * longitude);\r
-static int __metadata_extractor_get_latitude(metadata_extractor_s* metadata, double * latitude);\r
-static int __metadata_extractor_get_altitude(metadata_extractor_s* metadata, double * altitude);\r
-static int __metadata_extractor_get_conductor(metadata_extractor_s* metadata, char ** conductor);\r
-static int __metadata_extractor_get_unsynclyrics(metadata_extractor_s* metadata, char ** unsynclyrics);\r
-static int __metadata_extractor_get_recording_date(metadata_extractor_s* metadata, char ** rec_date);\r
-static int __metadata_extractor_get_synclyrics_pair_num(metadata_extractor_s* metadata, int * synclyrics_num);\r
-static int __metadata_extractor_destroy_handle(metadata_extractor_s* metadata);\r
-\r
-static int __metadata_extractor_create_content_attrs(metadata_extractor_s* metadata, const char* path)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       MMHandleType content = 0;\r
-       char * err_attr_name = NULL;\r
-\r
-       int _audio_track_cnt = 0;\r
-       int _video_track_cnt = 0;\r
-\r
-       LOGI("[%s] enter \n", __FUNCTION__);\r
-\r
-       ret = mm_file_create_content_attrs(&content, path);\r
-\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               if(ret == MM_ERROR_FILE_NOT_FOUND)\r
-               {\r
-                       LOGE("[%s]FILE_NOT_EXISTS(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_FILE_EXISTS);\r
-                       return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;\r
-               }\r
-               else\r
-               {\r
-                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       ret = mm_file_get_attrs(content, &err_attr_name,\r
-                                                       MM_FILE_CONTENT_VIDEO_TRACK_COUNT, &_video_track_cnt,\r
-                                                       MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &_audio_track_cnt,\r
-                                                       NULL);\r
-\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               mm_file_destroy_content_attrs(content);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       metadata->attr_h = content;\r
-       metadata->audio_track_cnt = _audio_track_cnt;\r
-       metadata->video_track_cnt = _video_track_cnt;\r
-\r
-       LOGI("[%s] leave \n", __FUNCTION__);\r
-\r
-       return ret;\r
-\r
-}\r
-\r
-\r
-static int __metadata_extractor_create_tag_attr(metadata_extractor_s* metadata, const char* path)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       MMHandleType tag = 0;\r
-\r
-       LOGI("[%s] enter \n", __FUNCTION__);\r
-       ret = mm_file_create_tag_attrs(&tag, path);\r
-\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               if(ret == MM_ERROR_FILE_NOT_FOUND)\r
-               {\r
-                       LOGE("[%s]FILE_NOT_EXISTS(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_FILE_EXISTS);\r
-                       return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;\r
-               }\r
-               else\r
-               {\r
-                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       metadata->tag_h= tag;\r
-\r
-       LOGI("[%s] leave \n", __FUNCTION__);\r
-       return ret;\r
-\r
-}\r
-\r
-static int __metadata_extractor_get_duration(metadata_extractor_s* metadata, int * duration)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _duration = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_DURATION, &_duration, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *duration = _duration;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_audio_bitrate(metadata_extractor_s* metadata, int * bitrate)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _audio_bitrate = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->audio_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &_audio_bitrate, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *bitrate = _audio_bitrate;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_audio_channel(metadata_extractor_s* metadata, int * channel)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _audio_channel = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->audio_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_CHANNELS, &_audio_channel, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *channel = _audio_channel;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_audio_samplerate(metadata_extractor_s* metadata, int * samplerate)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _audio_samplerate = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->audio_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &_audio_samplerate, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *samplerate = _audio_samplerate;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_audio_track_count(metadata_extractor_s* metadata, int * track_cnt)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-\r
-       if(!metadata)\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       *track_cnt = metadata->audio_track_cnt;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_video_bitrate(metadata_extractor_s* metadata, int * bitrate)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _video_bitrate = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->video_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_BITRATE, &_video_bitrate, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-       *bitrate = _video_bitrate;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_video_FPS(metadata_extractor_s* metadata, int * fps)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _video_fps = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->video_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_FPS, &_video_fps, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *fps = _video_fps;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_video_width(metadata_extractor_s* metadata, int * width)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _video_width = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->video_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_WIDTH, &_video_width, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *width = _video_width;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_video_height(metadata_extractor_s* metadata, int * height)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _video_height = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->video_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_HEIGHT, &_video_height, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *height = _video_height;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s* metadata, void ** thumbnail, int * thumbnail_len)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       void * _video_thumbnail = NULL;\r
-       int _video_thumbnail_len = 0;\r
-\r
-       if((!metadata) && (!metadata->attr_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       if(metadata->video_track_cnt > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &_video_thumbnail, &_video_thumbnail_len, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *thumbnail = _video_thumbnail;\r
-       *thumbnail_len = _video_thumbnail_len;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_video_track_count(metadata_extractor_s* metadata, int * track_cnt)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-\r
-       if(!metadata)\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       *track_cnt = metadata->video_track_cnt;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_artist(metadata_extractor_s* metadata, char ** artist)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _artist = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTIST, &_artist, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *artist = _artist;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_title(metadata_extractor_s* metadata, char ** title)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _title = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_TITLE, &_title, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *title = _title;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_album(metadata_extractor_s* metadata, char ** album)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _album = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ALBUM, &_album, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *album = _album;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_genre(metadata_extractor_s* metadata, char ** genre)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _genre = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_GENRE, &_genre, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *genre = _genre;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_author(metadata_extractor_s* metadata, char ** author)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _author = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_AUTHOR, &_author, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *author = _author;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_copyright(metadata_extractor_s* metadata, char ** copyright)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _copyright = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_COPYRIGHT, &_copyright, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *copyright = _copyright;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_date(metadata_extractor_s* metadata, char ** date)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _date = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_DATE, &_date, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *date = _date;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_description(metadata_extractor_s* metadata, char ** description)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _description = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_DESCRIPTION, &_description, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *description = _description;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_artwork(metadata_extractor_s* metadata, void ** artwork, int * artwork_size)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       void * _artwork = NULL;\r
-       int _artwork_size = 0;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name, MM_FILE_TAG_ARTWORK_SIZE, &_artwork_size, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       if(_artwork_size > 0)\r
-       {\r
-               ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTWORK, &_artwork, &_tag_len, NULL);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       SAFE_FREE(err_attr_name);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       *artwork = _artwork;\r
-       *artwork_size = _artwork_size;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_artwork_mime(metadata_extractor_s* metadata, char ** artwork_mime)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _artwork_mime = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTWORK_MIME, &_artwork_mime, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *artwork_mime = _artwork_mime;\r
-\r
-       return ret;\r
-}\r
-\r
-\r
-static int __metadata_extractor_get_track_num(metadata_extractor_s* metadata, char ** track_num)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _track_num = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_TRACK_NUM, &_track_num, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *track_num = _track_num;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_classification(metadata_extractor_s* metadata, char ** classification)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _classification = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_CLASSIFICATION, &_classification, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *classification = _classification;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_rating(metadata_extractor_s* metadata, char ** rating)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _rating = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_RATING, &_rating, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *rating = _rating;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_longitude(metadata_extractor_s* metadata, double * longitude)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       double _longitude = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_LONGITUDE, &_longitude, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *longitude = _longitude;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_latitude(metadata_extractor_s* metadata, double * latitude)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       double _latitude = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_LATIDUE, &_latitude, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *latitude = _latitude;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_altitude(metadata_extractor_s* metadata, double * altitude)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       double _altitude = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ALTIDUE, &_altitude, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *altitude = _altitude;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_conductor(metadata_extractor_s* metadata, char ** conductor)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _conductor = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_CONDUCTOR, &_conductor, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *conductor = _conductor;\r
-\r
-       return ret;\r
-}\r
-static int __metadata_extractor_get_unsynclyrics(metadata_extractor_s* metadata, char ** unsynclyrics)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _unsynclyrics = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_UNSYNCLYRICS, &_unsynclyrics, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *unsynclyrics = _unsynclyrics;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_recording_date(metadata_extractor_s* metadata, char ** rec_date)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       char * _rec_date = NULL;\r
-       int _tag_len = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_RECDATE, &_rec_date, &_tag_len, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *rec_date = _rec_date;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_get_synclyrics_pair_num(metadata_extractor_s* metadata, int * synclyrics_num)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       char * err_attr_name = NULL;\r
-       int _synclyrics_num = 0;\r
-\r
-       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_SYNCLYRICS_NUM, &_synclyrics_num, NULL);\r
-       if(ret != MM_ERROR_NONE)\r
-       {\r
-               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-               SAFE_FREE(err_attr_name);\r
-               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-       }\r
-\r
-       *synclyrics_num = _synclyrics_num;\r
-\r
-       return ret;\r
-}\r
-\r
-static int __metadata_extractor_destroy_handle(metadata_extractor_s* metadata)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-\r
-       LOGI("[%s] enter \n", __FUNCTION__);\r
-\r
-       if(metadata->attr_h)\r
-       {\r
-               ret = mm_file_destroy_content_attrs(metadata->attr_h);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       if(metadata->tag_h)\r
-       {\r
-               ret = mm_file_destroy_tag_attrs(metadata->tag_h);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-       }\r
-\r
-       LOGI("[%s] leave \n", __FUNCTION__);\r
-\r
-       return ret;\r
-}\r
-\r
-\r
-int metadata_extractor_create(metadata_extractor_h* metadata)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-\r
-       LOGI("[%s] enter \n", __FUNCTION__);\r
-\r
-       if(metadata == NULL)\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       metadata_extractor_s* _metadata = (metadata_extractor_s*)calloc(1,sizeof(metadata_extractor_s));\r
-       if(_metadata == NULL)\r
-       {\r
-               LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);\r
-               return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;\r
-       }\r
-\r
-       *metadata = (metadata_extractor_h)_metadata;\r
-\r
-       LOGI("[%s] leave \n", __FUNCTION__);\r
-\r
-       return ret;\r
-}\r
-\r
-int metadata_extractor_set_path(metadata_extractor_h metadata, const char* path)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       metadata_extractor_s* _metadata = (metadata_extractor_s*)metadata;\r
-\r
-       LOGI("[%s] enter \n", __FUNCTION__);\r
-\r
-       if((_metadata == NULL) || (path == NULL))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       LOGI("[%s] path [%s] \n", __FUNCTION__, path);\r
-\r
-       if((_metadata->attr_h) || (_metadata->tag_h))\r
-       {\r
-               LOGI("[%s]Handle already exist", __FUNCTION__);\r
-               ret = __metadata_extractor_destroy_handle(_metadata);\r
-               if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]Fail to destory handle(0x%08x)", __FUNCTION__, ret);\r
-                       return ret;\r
-               }\r
-\r
-               memset(_metadata, 0x00, sizeof(metadata_extractor_s));\r
-       }\r
-\r
-       ret = __metadata_extractor_create_content_attrs(_metadata, path);\r
-       if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-       {\r
-               return ret;\r
-       }\r
-\r
-       ret = __metadata_extractor_create_tag_attr(_metadata, path);\r
-       if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-       {\r
-               return ret;\r
-       }\r
-\r
-       LOGI("[%s] leave \n", __FUNCTION__);\r
-\r
-       return ret;\r
-}\r
-\r
-int metadata_extractor_destroy(metadata_extractor_h metadata)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-\r
-       LOGI("[%s] enter \n", __FUNCTION__);\r
-\r
-       if(!metadata)\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       ret = __metadata_extractor_destroy_handle(metadata);\r
-\r
-       SAFE_FREE(metadata);\r
-\r
-       LOGI("[%s] leave \n", __FUNCTION__);\r
-\r
-       return ret;\r
-}\r
-\r
-int metadata_extractor_get_synclyrics(metadata_extractor_h metadata, int index, unsigned long *time_stamp, char ** lyrics)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       metadata_extractor_s* _metadata = (metadata_extractor_s*)metadata;\r
-       unsigned long _time_info = 0;\r
-       char * _lyrics = NULL;\r
-       int _synclyrics_num = 0;\r
-\r
-       if((!_metadata) || (!_metadata->attr_h) || (!_metadata->tag_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       ret = __metadata_extractor_get_synclyrics_pair_num(_metadata, &_synclyrics_num);\r
-       if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-       {\r
-               return ret;\r
-       }\r
-\r
-       if((_synclyrics_num > 0) && (index < _synclyrics_num))\r
-       {\r
-               ret = mm_file_get_synclyrics_info((MMHandleType)_metadata->tag_h, index, &_time_info, &_lyrics);\r
-               if(ret != MM_ERROR_NONE)\r
-               {\r
-                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);\r
-                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;\r
-               }\r
-\r
-               *lyrics = _lyrics;\r
-               *time_stamp = _time_info;\r
-       }\r
-       else\r
-       {\r
-               *lyrics = NULL;\r
-               *time_stamp = 0;\r
-       }\r
-\r
-       return ret;\r
-}\r
-\r
-int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extractor_attr_e attribute, char ** value)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       metadata_extractor_s* _metadata = (metadata_extractor_s*)metadata;\r
-       int i_value = 0;\r
-       double d_value = 0;\r
-       char * s_value = NULL;\r
-       int is_string = 0;\r
-       int is_double = 0;\r
-\r
-       if((!_metadata) || (!_metadata->attr_h) || (!_metadata->tag_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       switch (attribute) {\r
-               case METADATA_DURATION:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_duration(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_VIDEO_BITRATE:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_video_bitrate(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_VIDEO_FPS:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_video_FPS(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_VIDEO_WIDTH:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_video_width(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_VIDEO_HEIGHT:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_video_height(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_HAS_VIDEO:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_video_track_count(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_AUDIO_BITRATE:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_audio_bitrate(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_AUDIO_CHANNELS:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_audio_channel(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_AUDIO_SAMPLERATE:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_audio_samplerate(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_HAS_AUDIO:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_audio_track_count(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_ARTIST:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_artist(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_TITLE:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_title(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_ALBUM:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_album(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_GENRE:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_genre(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_AUTHOR:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_author(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_COPYRIGHT:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_copyright(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_DATE:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_date(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_DESCRIPTION:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_description(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_TRACK_NUM:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_track_num(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_CLASSIFICATION:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_classification(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_RATING:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_rating(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_LONGITUDE:\r
-               {\r
-                       is_double = 1;\r
-                       ret = __metadata_extractor_get_longitude(_metadata, &d_value);\r
-                       break;\r
-               }\r
-               case METADATA_LATITUDE:\r
-               {\r
-                       is_double = 1;\r
-                       ret = __metadata_extractor_get_latitude(_metadata, &d_value);\r
-                       break;\r
-               }\r
-               case METADATA_ALTITUDE:\r
-               {\r
-                       is_double = 1;\r
-                       ret = __metadata_extractor_get_altitude(_metadata, &d_value);\r
-                       break;\r
-               }\r
-               case METADATA_CONDUCTOR:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_conductor(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_UNSYNCLYRICS:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_unsynclyrics(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               case METADATA_SYNCLYRICS_NUM:\r
-               {\r
-                       is_string = 0;\r
-                       ret = __metadata_extractor_get_synclyrics_pair_num(_metadata, &i_value);\r
-                       break;\r
-               }\r
-               case METADATA_RECDATE:\r
-               {\r
-                       is_string = 1;\r
-                       ret = __metadata_extractor_get_recording_date(_metadata, &s_value);\r
-                       break;\r
-               }\r
-               default:\r
-               {\r
-                       LOGE("[%s]INVALID_PARAMETER [%d] (0x%08x)", __FUNCTION__, attribute, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-                       return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-               }\r
-       }\r
-\r
-       if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-       {\r
-               *value = NULL;\r
-               return ret;\r
-       }\r
-\r
-       if(is_string)\r
-       {\r
-               if((s_value != NULL) && (strlen(s_value) > 0))\r
-               {\r
-                       *value = strdup(s_value);\r
-                       if(*value == NULL)\r
-                       {\r
-                               LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);\r
-                               return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;\r
-                       }\r
-               }\r
-               else\r
-               {\r
-                       *value = NULL;\r
-               }\r
-       }\r
-       else\r
-       {\r
-               char metadata[META_MAX_LEN] = {0, };\r
-\r
-               if(is_double)\r
-               {\r
-                       snprintf(metadata, sizeof(metadata), "%f", d_value);\r
-               }\r
-               else\r
-               {\r
-                       snprintf(metadata, sizeof(metadata), "%d", i_value);\r
-               }\r
-\r
-               *value = strdup(metadata);\r
-       }\r
-\r
-       return ret;\r
-}\r
-\r
-int metadata_extractor_get_artwork(metadata_extractor_h metadata, void ** artwork, int * size, char ** mime_type)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       metadata_extractor_s* _metadata = (metadata_extractor_s*)metadata;\r
-       void * _artwork = NULL;\r
-       int _artwork_size = 0;\r
-       char * _artwork_mime = NULL;\r
-\r
-       if((!_metadata) || (!_metadata->attr_h) || (!_metadata->tag_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       ret = __metadata_extractor_get_artwork(_metadata, &_artwork, &_artwork_size);\r
-       if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-       {\r
-               return ret;\r
-       }\r
-\r
-       if((_artwork_size > 0) && (_artwork != NULL))\r
-       {\r
-               ret = __metadata_extractor_get_artwork_mime(_metadata, &_artwork_mime);\r
-               if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-               {\r
-                       *artwork = NULL;\r
-                       *size = 0;\r
-\r
-                       return ret;\r
-               }\r
-\r
-               *artwork = calloc(1, _artwork_size);\r
-               memcpy(*artwork, _artwork, _artwork_size);\r
-               *size = _artwork_size;\r
-\r
-               if((_artwork_mime != NULL) && (strlen(_artwork_mime) > 0))\r
-               {\r
-                       *mime_type = strdup(_artwork_mime);\r
-                       if(*mime_type == NULL)\r
-                       {\r
-                               LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);\r
-                               return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;\r
-                       }\r
-               }\r
-               else\r
-               {\r
-                       *mime_type = NULL;\r
-               }\r
-\r
-       }\r
-       else\r
-       {\r
-               *artwork = NULL;\r
-               *mime_type = NULL;\r
-               *size = 0;\r
-       }\r
-\r
-       return ret;\r
-}\r
-\r
-int metadata_extractor_get_frame(metadata_extractor_h metadata, void ** frame, int * size)\r
-{\r
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;\r
-       metadata_extractor_s* _metadata = (metadata_extractor_s*)metadata;\r
-       void * _frame = NULL;\r
-       int _frame_size = 0;\r
-\r
-       if((!_metadata) || (!_metadata->attr_h) || (!_metadata->tag_h))\r
-       {\r
-               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);\r
-               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;\r
-       }\r
-\r
-       ret = __metadata_extractor_get_video_thumbnail(_metadata, &_frame, &_frame_size);\r
-       if(ret != METADATA_EXTRACTOR_ERROR_NONE)\r
-       {\r
-               return ret;\r
-       }\r
-\r
-       if((_frame_size > 0) && (_frame != NULL))\r
-       {\r
-               *frame = calloc(1, _frame_size);\r
-               if(*frame == NULL)\r
-               {\r
-                       LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);\r
-                       return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;\r
-               }\r
-               memcpy(*frame, _frame, _frame_size);\r
-               *size = _frame_size;\r
-       }\r
-       else\r
-       {\r
-               *frame = NULL;\r
-               *size = 0;\r
-       }\r
-\r
-       return ret;\r
-}\r
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <mm_file.h>
+#include <mm_error.h>
+#include <dlog.h>
+#include <metadata_extractor.h>
+#include <metadata_extractor_private.h>
+
+#define SAFE_FREE(src)      { if(src) {free(src); src = NULL;}}
+#define META_MAX_LEN   256
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_METADATAEXTRACTOR"
+
+static int __metadata_extractor_check_and_extract_meta(metadata_extractor_s *metadata);
+static int __metadata_extractor_create_content_attrs(metadata_extractor_s *metadata, const char *path);
+static int __metadata_extractor_create_tag_attr(metadata_extractor_s *metadata, const char *path);
+static int __metadata_extractor_get_artwork(metadata_extractor_s *metadata, void **artwork, int *artwork_size);
+static int __metadata_extractor_get_artwork_mime(metadata_extractor_s *metadata, char **artwork_mime);
+static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s *metadata, void **thumbnail, int *thumbnail_len);
+static int __metadata_extractor_get_duration(metadata_extractor_s *metadata, int *duration);
+static int __metadata_extractor_get_audio_bitrate(metadata_extractor_s *metadata, int *bitrate);
+static int __metadata_extractor_get_audio_channel(metadata_extractor_s *metadata, int *channel);
+static int __metadata_extractor_get_audio_samplerate(metadata_extractor_s *metadata, int *samplerate);
+static int __metadata_extractor_get_audio_track_count(metadata_extractor_s *metadata, int *track_cnt);
+static int __metadata_extractor_get_video_bitrate(metadata_extractor_s *metadata, int *bitrate);
+static int __metadata_extractor_get_video_FPS(metadata_extractor_s *metadata, int *fps);
+static int __metadata_extractor_get_video_width(metadata_extractor_s *metadata, int *width);
+static int __metadata_extractor_get_video_height(metadata_extractor_s *metadata, int *height);
+static int __metadata_extractor_get_video_track_count(metadata_extractor_s *metadata, int *track_cnt);
+static int __metadata_extractor_get_artist(metadata_extractor_s *metadata, char **artist);
+static int __metadata_extractor_get_title(metadata_extractor_s *metadata, char **title);
+static int __metadata_extractor_get_album(metadata_extractor_s *metadata, char **album);
+static int __metadata_extractor_get_genre(metadata_extractor_s *metadata, char **genre);
+static int __metadata_extractor_get_author(metadata_extractor_s *metadata, char **author);
+static int __metadata_extractor_get_copyright(metadata_extractor_s *metadata, char **copyright);
+static int __metadata_extractor_get_date(metadata_extractor_s *metadata, char **date);
+static int __metadata_extractor_get_description(metadata_extractor_s *metadata, char **description);
+static int __metadata_extractor_get_track_num(metadata_extractor_s *metadata, char **track_num);
+static int __metadata_extractor_get_classification(metadata_extractor_s *metadata, char **classification);
+static int __metadata_extractor_get_rating(metadata_extractor_s *metadata, char **rating);
+static int __metadata_extractor_get_longitude(metadata_extractor_s *metadata, double *longitude);
+static int __metadata_extractor_get_latitude(metadata_extractor_s *metadata, double *latitude);
+static int __metadata_extractor_get_altitude(metadata_extractor_s *metadata, double *altitude);
+static int __metadata_extractor_get_conductor(metadata_extractor_s *metadata, char **conductor);
+static int __metadata_extractor_get_unsynclyrics(metadata_extractor_s *metadata, char **unsynclyrics);
+static int __metadata_extractor_get_recording_date(metadata_extractor_s *metadata, char **rec_date);
+static int __metadata_extractor_get_synclyrics_pair_num(metadata_extractor_s *metadata, int *synclyrics_num);
+static int __metadata_extractor_destroy_handle(metadata_extractor_s *metadata);
+
+static int __metadata_extractor_check_and_extract_meta(metadata_extractor_s *metadata)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if(metadata->extract_meta)
+       {
+               LOGI("[%s] metadata already extracted \n", __FUNCTION__);
+               return ret;
+       }
+
+       ret = __metadata_extractor_create_content_attrs(metadata, metadata->path);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       ret = __metadata_extractor_create_tag_attr(metadata, metadata->path);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       metadata->extract_meta = true;
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+static int __metadata_extractor_create_content_attrs(metadata_extractor_s *metadata, const char *path)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       MMHandleType content = 0;
+       char *err_attr_name = NULL;
+
+       int _audio_track_cnt = 0;
+       int _video_track_cnt = 0;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       ret = mm_file_create_content_attrs(&content, path);
+
+       if(ret != MM_ERROR_NONE)
+       {
+               if(ret == MM_ERROR_FILE_NOT_FOUND)
+               {
+                       LOGE("[%s]FILE_NOT_EXISTS(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
+                       return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
+               }
+               else
+               {
+                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       ret = mm_file_get_attrs(content, &err_attr_name,
+                                                       MM_FILE_CONTENT_VIDEO_TRACK_COUNT, &_video_track_cnt,
+                                                       MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &_audio_track_cnt,
+                                                       NULL);
+
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               mm_file_destroy_content_attrs(content);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       metadata->attr_h = content;
+       metadata->audio_track_cnt = _audio_track_cnt;
+       metadata->video_track_cnt = _video_track_cnt;
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+
+}
+
+
+static int __metadata_extractor_create_tag_attr(metadata_extractor_s *metadata, const char *path)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       MMHandleType tag = 0;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+       ret = mm_file_create_tag_attrs(&tag, path);
+
+       if(ret != MM_ERROR_NONE)
+       {
+               if(ret == MM_ERROR_FILE_NOT_FOUND)
+               {
+                       LOGE("[%s]FILE_NOT_EXISTS(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
+                       return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
+               }
+               else
+               {
+                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       metadata->tag_h= tag;
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+       return ret;
+
+}
+
+static int __metadata_extractor_get_duration(metadata_extractor_s *metadata, int *duration)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _duration = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_DURATION, &_duration, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *duration = _duration;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_audio_bitrate(metadata_extractor_s *metadata, int *bitrate)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _audio_bitrate = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->audio_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &_audio_bitrate, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *bitrate = _audio_bitrate;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_audio_channel(metadata_extractor_s *metadata, int *channel)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _audio_channel = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->audio_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_CHANNELS, &_audio_channel, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *channel = _audio_channel;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_audio_samplerate(metadata_extractor_s *metadata, int *samplerate)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _audio_samplerate = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->audio_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &_audio_samplerate, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *samplerate = _audio_samplerate;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_audio_track_count(metadata_extractor_s *metadata, int *track_cnt)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+
+       if(!metadata)
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       *track_cnt = metadata->audio_track_cnt;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_video_bitrate(metadata_extractor_s *metadata, int *bitrate)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _video_bitrate = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->video_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_BITRATE, &_video_bitrate, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+       *bitrate = _video_bitrate;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_video_FPS(metadata_extractor_s *metadata, int *fps)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _video_fps = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->video_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_FPS, &_video_fps, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *fps = _video_fps;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_video_width(metadata_extractor_s *metadata, int *width)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _video_width = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->video_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_WIDTH, &_video_width, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *width = _video_width;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_video_height(metadata_extractor_s *metadata, int *height)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _video_height = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->video_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_HEIGHT, &_video_height, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *height = _video_height;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s *metadata, void **thumbnail, int *thumbnail_len)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       void *_video_thumbnail = NULL;
+       int _video_thumbnail_len = 0;
+
+       if((!metadata) && (!metadata->attr_h))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       if(metadata->video_track_cnt > 0)
+       {
+               ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &_video_thumbnail, &_video_thumbnail_len, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *thumbnail = _video_thumbnail;
+       *thumbnail_len = _video_thumbnail_len;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_video_track_count(metadata_extractor_s *metadata, int *track_cnt)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+
+       if(!metadata)
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       *track_cnt = metadata->video_track_cnt;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_artist(metadata_extractor_s *metadata, char **artist)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_artist = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTIST, &_artist, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *artist = _artist;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_title(metadata_extractor_s *metadata, char **title)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_title = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_TITLE, &_title, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *title = _title;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_album(metadata_extractor_s *metadata, char **album)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_album = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ALBUM, &_album, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *album = _album;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_genre(metadata_extractor_s *metadata, char **genre)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_genre = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_GENRE, &_genre, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *genre = _genre;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_author(metadata_extractor_s *metadata, char **author)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_author = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_AUTHOR, &_author, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *author = _author;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_copyright(metadata_extractor_s *metadata, char **copyright)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_copyright = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_COPYRIGHT, &_copyright, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *copyright = _copyright;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_date(metadata_extractor_s *metadata, char **date)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_date = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_DATE, &_date, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *date = _date;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_description(metadata_extractor_s *metadata, char **description)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_description = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_DESCRIPTION, &_description, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *description = _description;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_artwork(metadata_extractor_s *metadata, void **artwork, int *artwork_size)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       void *_artwork = NULL;
+       int _artwork_size = 0;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name, MM_FILE_TAG_ARTWORK_SIZE, &_artwork_size, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       if(_artwork_size > 0)
+       {
+               ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTWORK, &_artwork, &_tag_len, NULL);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       SAFE_FREE(err_attr_name);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       *artwork = _artwork;
+       *artwork_size = _artwork_size;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_artwork_mime(metadata_extractor_s *metadata, char **artwork_mime)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_artwork_mime = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTWORK_MIME, &_artwork_mime, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *artwork_mime = _artwork_mime;
+
+       return ret;
+}
+
+
+static int __metadata_extractor_get_track_num(metadata_extractor_s *metadata, char **track_num)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_track_num = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_TRACK_NUM, &_track_num, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *track_num = _track_num;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_classification(metadata_extractor_s *metadata, char **classification)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_classification = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_CLASSIFICATION, &_classification, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *classification = _classification;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_rating(metadata_extractor_s *metadata, char **rating)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_rating = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_RATING, &_rating, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *rating = _rating;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_longitude(metadata_extractor_s *metadata, double *longitude)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       double _longitude = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_LONGITUDE, &_longitude, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *longitude = _longitude;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_latitude(metadata_extractor_s *metadata, double *latitude)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       double _latitude = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_LATIDUE, &_latitude, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *latitude = _latitude;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_altitude(metadata_extractor_s *metadata, double *altitude)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       double _altitude = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ALTIDUE, &_altitude, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *altitude = _altitude;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_conductor(metadata_extractor_s *metadata, char **conductor)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_conductor = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_CONDUCTOR, &_conductor, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *conductor = _conductor;
+
+       return ret;
+}
+static int __metadata_extractor_get_unsynclyrics(metadata_extractor_s *metadata, char **unsynclyrics)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_unsynclyrics = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_UNSYNCLYRICS, &_unsynclyrics, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *unsynclyrics = _unsynclyrics;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_recording_date(metadata_extractor_s *metadata, char **rec_date)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       char *_rec_date = NULL;
+       int _tag_len = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_RECDATE, &_rec_date, &_tag_len, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *rec_date = _rec_date;
+
+       return ret;
+}
+
+static int __metadata_extractor_get_synclyrics_pair_num(metadata_extractor_s *metadata, int *synclyrics_num)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       char *err_attr_name = NULL;
+       int _synclyrics_num = 0;
+
+       ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_SYNCLYRICS_NUM, &_synclyrics_num, NULL);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]err_attr_name(%s), ERROR_UNKNOWN(0x%08x)", __FUNCTION__, err_attr_name, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               SAFE_FREE(err_attr_name);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       *synclyrics_num = _synclyrics_num;
+
+       return ret;
+}
+
+static int __metadata_extractor_destroy_handle(metadata_extractor_s *metadata)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if(metadata->attr_h)
+       {
+               ret = mm_file_destroy_content_attrs(metadata->attr_h);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       if(metadata->tag_h)
+       {
+               ret = mm_file_destroy_tag_attrs(metadata->tag_h);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+       }
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+
+int metadata_extractor_create(metadata_extractor_h *metadata)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if(metadata == NULL)
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)calloc(1,sizeof(metadata_extractor_s));
+       if(_metadata == NULL)
+       {
+               LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
+               return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
+       }
+
+       _metadata->path = NULL;
+       _metadata->extract_meta = false;
+       _metadata->audio_track_cnt = 0;
+       _metadata->video_track_cnt = 0;
+
+       *metadata = (metadata_extractor_h)_metadata;
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+int metadata_extractor_set_path(metadata_extractor_h metadata, const char *path)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if((_metadata == NULL) || (path == NULL))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       LOGI("[%s] path [%s] \n", __FUNCTION__, path);
+
+       if(_metadata->path != NULL)
+       {
+               SAFE_FREE(_metadata->path);
+               _metadata->extract_meta = false;
+       }
+
+       _metadata->path = strdup(path);
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+int metadata_extractor_destroy(metadata_extractor_h metadata)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if(!_metadata)
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       ret = __metadata_extractor_destroy_handle(_metadata);
+
+       SAFE_FREE(_metadata->path);
+
+       SAFE_FREE(_metadata);
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+int metadata_extractor_get_synclyrics(metadata_extractor_h metadata, int index, unsigned long *time_stamp, char **lyrics)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+       unsigned long _time_info = 0;
+       char *_lyrics = NULL;
+       int _synclyrics_num = 0;
+
+       if((!_metadata) || (!_metadata->path))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       ret = __metadata_extractor_check_and_extract_meta(_metadata);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       ret = __metadata_extractor_get_synclyrics_pair_num(_metadata, &_synclyrics_num);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       if((_synclyrics_num > 0) && (index < _synclyrics_num))
+       {
+               ret = mm_file_get_synclyrics_info((MMHandleType)_metadata->tag_h, index, &_time_info, &_lyrics);
+               if(ret != MM_ERROR_NONE)
+               {
+                       LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+                       return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+               }
+
+               *lyrics = _lyrics;
+               *time_stamp = _time_info;
+       }
+       else
+       {
+               *lyrics = NULL;
+               *time_stamp = 0;
+       }
+
+       return ret;
+}
+
+int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extractor_attr_e attribute, char **value)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+       int i_value = 0;
+       double d_value = 0;
+       char *s_value = NULL;
+       int is_string = 0;
+       int is_double = 0;
+
+       if((!_metadata) || (!_metadata->path))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       ret = __metadata_extractor_check_and_extract_meta(_metadata);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       switch (attribute) {
+               case METADATA_DURATION:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_duration(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_VIDEO_BITRATE:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_video_bitrate(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_VIDEO_FPS:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_video_FPS(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_VIDEO_WIDTH:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_video_width(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_VIDEO_HEIGHT:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_video_height(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_HAS_VIDEO:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_video_track_count(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_AUDIO_BITRATE:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_audio_bitrate(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_AUDIO_CHANNELS:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_audio_channel(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_AUDIO_SAMPLERATE:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_audio_samplerate(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_HAS_AUDIO:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_audio_track_count(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_ARTIST:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_artist(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_TITLE:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_title(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_ALBUM:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_album(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_GENRE:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_genre(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_AUTHOR:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_author(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_COPYRIGHT:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_copyright(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_DATE:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_date(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_DESCRIPTION:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_description(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_TRACK_NUM:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_track_num(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_CLASSIFICATION:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_classification(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_RATING:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_rating(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_LONGITUDE:
+               {
+                       is_double = 1;
+                       ret = __metadata_extractor_get_longitude(_metadata, &d_value);
+                       break;
+               }
+               case METADATA_LATITUDE:
+               {
+                       is_double = 1;
+                       ret = __metadata_extractor_get_latitude(_metadata, &d_value);
+                       break;
+               }
+               case METADATA_ALTITUDE:
+               {
+                       is_double = 1;
+                       ret = __metadata_extractor_get_altitude(_metadata, &d_value);
+                       break;
+               }
+               case METADATA_CONDUCTOR:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_conductor(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_UNSYNCLYRICS:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_unsynclyrics(_metadata, &s_value);
+                       break;
+               }
+               case METADATA_SYNCLYRICS_NUM:
+               {
+                       is_string = 0;
+                       ret = __metadata_extractor_get_synclyrics_pair_num(_metadata, &i_value);
+                       break;
+               }
+               case METADATA_RECDATE:
+               {
+                       is_string = 1;
+                       ret = __metadata_extractor_get_recording_date(_metadata, &s_value);
+                       break;
+               }
+               default:
+               {
+                       LOGE("[%s]INVALID_PARAMETER [%d] (0x%08x)", __FUNCTION__, attribute, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+                       return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+               }
+       }
+
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               *value = NULL;
+               return ret;
+       }
+
+       if(is_string)
+       {
+               if((s_value != NULL) && (strlen(s_value) > 0))
+               {
+                       *value = strdup(s_value);
+                       if(*value == NULL)
+                       {
+                               LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
+                               return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
+                       }
+               }
+               else
+               {
+                       *value = NULL;
+               }
+       }
+       else
+       {
+               char metadata[META_MAX_LEN] = {0, };
+
+               if(is_double)
+               {
+                       snprintf(metadata, sizeof(metadata), "%f", d_value);
+               }
+               else
+               {
+                       snprintf(metadata, sizeof(metadata), "%d", i_value);
+               }
+
+               *value = strdup(metadata);
+       }
+
+       return ret;
+}
+
+int metadata_extractor_get_artwork(metadata_extractor_h metadata, void **artwork, int *size, char **mime_type)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+       void *_artwork = NULL;
+       int _artwork_size = 0;
+       char *_artwork_mime = NULL;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if((!_metadata) || (!_metadata->path))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       ret = __metadata_extractor_check_and_extract_meta(_metadata);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       ret = __metadata_extractor_get_artwork(_metadata, &_artwork, &_artwork_size);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       if((_artwork_size > 0) && (_artwork != NULL))
+       {
+               ret = __metadata_extractor_get_artwork_mime(_metadata, &_artwork_mime);
+               if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+               {
+                       *artwork = NULL;
+                       *size = 0;
+
+                       return ret;
+               }
+
+               *artwork = calloc(1, _artwork_size);
+               memcpy(*artwork, _artwork, _artwork_size);
+               *size = _artwork_size;
+
+               if((_artwork_mime != NULL) && (strlen(_artwork_mime) > 0))
+               {
+                       *mime_type = strdup(_artwork_mime);
+                       if(*mime_type == NULL)
+                       {
+                               LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
+                               return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
+                       }
+               }
+               else
+               {
+                       *mime_type = NULL;
+               }
+
+       }
+       else
+       {
+               *artwork = NULL;
+               *mime_type = NULL;
+               *size = 0;
+       }
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+int metadata_extractor_get_frame(metadata_extractor_h metadata, void **frame, int *size)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+       void *_frame = NULL;
+       int _frame_size = 0;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if((!_metadata) || (!_metadata->path) || (!size))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       ret = __metadata_extractor_check_and_extract_meta(_metadata);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       ret = __metadata_extractor_get_video_thumbnail(_metadata, &_frame, &_frame_size);
+       if(ret != METADATA_EXTRACTOR_ERROR_NONE)
+       {
+               return ret;
+       }
+
+       if((_frame_size > 0) && (_frame != NULL))
+       {
+               *frame = calloc(1, _frame_size);
+               if(*frame == NULL)
+               {
+                       LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
+                       return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
+               }
+               memcpy(*frame, _frame, _frame_size);
+               *size = _frame_size;
+       }
+       else
+       {
+               *frame = NULL;
+               *size = 0;
+       }
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}
+
+int metadata_extractor_get_frame_at_time(metadata_extractor_h metadata, unsigned long timestamp, bool is_accurate, void **frame, int *size)
+{
+       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       metadata_extractor_s *_metadata = (metadata_extractor_s*)metadata;
+       void *_frame = NULL;
+       int _frame_size = 0;
+       int width = 0;
+       int height = 0;
+       long micro_timestamp = 0;
+
+       LOGI("[%s] enter \n", __FUNCTION__);
+
+       if((!_metadata) || (!_metadata->path) || (timestamp < 0) || (!size))
+       {
+               LOGE("[%s]INVALID_PARAMETER(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
+       }
+
+       micro_timestamp = timestamp * 1000;
+
+       ret = mm_file_get_video_frame(_metadata->path, micro_timestamp, is_accurate, (unsigned char **)&_frame, &_frame_size, &width, &height);
+       if(ret != MM_ERROR_NONE)
+       {
+               LOGE("[%s]ERROR_UNKNOWN(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
+               return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
+       }
+
+       if((_frame_size > 0) && (_frame != NULL))
+       {
+               *frame = calloc(1, _frame_size);
+               if(*frame == NULL)
+               {
+                       LOGE("[%s]OUT_OF_MEMORY(0x%08x)", __FUNCTION__, METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
+                       return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
+               }
+               memcpy(*frame, _frame, _frame_size);
+               *size = _frame_size;
+       }
+       else
+       {
+               *frame = NULL;
+               *size = 0;
+       }
+
+       LOGI("[%s] leave \n", __FUNCTION__);
+
+       return ret;
+}

diff --git a/test/multimeida_metadata_extractor_test.c b/test/multimeida_metadata_extractor_test.c
index 01ab89d..3d2b703 100755 (executable)
--- a/test/multimeida_metadata_extractor_test.c
+++ b/test/multimeida_metadata_extractor_test.c
@@ -18,6 +18,7 @@
 #include <stdlib.h>\r
 #include <string.h>\r
 #include <unistd.h>\r
+#include <stdbool.h>\r
 #include <dlog.h>\r
 #include <metadata_extractor.h>\r
 \r
@@ -36,7 +37,7 @@ static int _is_file_exist (const char *filename)
 {\r
        int ret = 1;\r
        if (filename) {\r
-               const char* to_access = (strstr(filename,"file://")!=NULL)? filename+7:filename;\r
+               const char *to_access = (strstr(filename,"file://")!=NULL)? filename+7:filename;\r
                ret = access (to_access, R_OK );\r
                if (ret != 0) {\r
                        LOGI("file [%s] not found.\n", to_access);\r
@@ -45,48 +46,49 @@ static int _is_file_exist (const char *filename)
        return !ret;\r
 }\r
 \r
-//bool capi_metadata_extractor_cb(metadata_extractor_h metadata, void* user_data)\r
 static bool __capi_metadata_extractor(metadata_extractor_h metadata)\r
 {\r
-       char * duration = 0;\r
-       char * audio_bitrate = 0;\r
-       char * audio_channel = 0;\r
-       char * audio_samplerate = 0;\r
-       char * audio_track_cnt = 0;\r
-       char * video_bitrate = 0;\r
-       char * video_fps = 0;\r
-       char * video_width = 0;\r
-       char * video_height = 0;\r
-       char * video_track_cnt = 0;\r
-       void * video_thumbnail = NULL;\r
+       char *duration = 0;\r
+       char *audio_bitrate = 0;\r
+       char *audio_channel = 0;\r
+       char *audio_samplerate = 0;\r
+       char *audio_track_cnt = 0;\r
+       char *video_bitrate = 0;\r
+       char *video_fps = 0;\r
+       char *video_width = 0;\r
+       char *video_height = 0;\r
+       char *video_track_cnt = 0;\r
+       void *video_thumbnail = NULL;\r
        int video_thumbnail_len = 0;\r
+       void *video_frame = NULL;\r
+       int video_frame_len = 0;\r
 \r
        /*Tag info*/\r
-       char * artist = NULL;\r
-       char * title = NULL;\r
-       char * album = NULL;\r
-       char * genre = NULL;\r
-       char * author = NULL;\r
-       char * copyright = NULL;\r
-       char * date = NULL;\r
-       char * description = NULL;\r
-       void * artwork = NULL;\r
+       char *artist = NULL;\r
+       char *title = NULL;\r
+       char *album = NULL;\r
+       char *genre = NULL;\r
+       char *author = NULL;\r
+       char *copyright = NULL;\r
+       char *date = NULL;\r
+       char *description = NULL;\r
+       void *artwork = NULL;\r
        int artwork_size = 0;\r
-       char * artwork_mime = NULL;\r
-       char * track_num = NULL;\r
-       char * classification = NULL;\r
-       char * rating = NULL;\r
-       char * longitude = 0;\r
-       char * latitude = 0;\r
-       char * altitude = 0;\r
-       char * conductor = NULL;\r
-       char * unsynclyrics = NULL;\r
-       char * synclyrics_num = 0;\r
-       char * rec_date = NULL;\r
+       char *artwork_mime = NULL;\r
+       char *track_num = NULL;\r
+       char *classification = NULL;\r
+       char *rating = NULL;\r
+       char *longitude = 0;\r
+       char *latitude = 0;\r
+       char *altitude = 0;\r
+       char *conductor = NULL;\r
+       char *unsynclyrics = NULL;\r
+       char *synclyrics_num = 0;\r
+       char *rec_date = NULL;\r
 \r
        int idx = 0;\r
-       unsigned long  time_info = 0;\r
-       char * lyrics = NULL;\r
+       unsigned long time_info = 0;\r
+       char *lyrics = NULL;\r
 \r
        if(metadata == NULL)\r
        {\r
@@ -169,6 +171,10 @@ static bool __capi_metadata_extractor(metadata_extractor_h metadata)
        metadata_extractor_get_frame(metadata, &video_thumbnail, &video_thumbnail_len);\r
        LOGI("video_thumbnail[%p], video_thumbnail_len = [%d]\n\n", video_thumbnail, video_thumbnail_len);\r
 \r
+       /*Get Video frame at time, extract frame of 22.5 sec and not key frame*/\r
+       metadata_extractor_get_frame_at_time(metadata, 22500, false, &video_frame, &video_frame_len);\r
+       LOGI("video_frame[%p], video_frame_len = [%d]\n\n", video_frame, video_frame_len);\r
+\r
        SAFE_FREE(duration );\r
        SAFE_FREE(audio_bitrate );\r
        SAFE_FREE(audio_channel );\r
@@ -180,6 +186,7 @@ static bool __capi_metadata_extractor(metadata_extractor_h metadata)
        SAFE_FREE(video_height );\r
        SAFE_FREE(video_track_cnt );\r
        SAFE_FREE(video_thumbnail);\r
+       SAFE_FREE(video_frame);\r
 \r
        SAFE_FREE(artist);\r
        SAFE_FREE(title);\r