src/common/media-svc-util.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <unistd.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25 #include <string.h>
  26 #include <sys/vfs.h>
  27 #include <glib/gstdio.h>
  28 #include <sys/stat.h>
  29 #include <string.h>
  30 #include <dirent.h>
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #include <aul/aul.h>
  34 #include <mm_file.h>
  35 #include <mm_error.h>
  36 #include <libexif/exif-data.h>
  37 #include <media-thumbnail.h>
  38 #include <media-util.h>
  39 #include "uuid.h"
  40 #include "media-svc-util.h"
  41 #include "media-svc-error.h"
  42 #include "media-svc-debug.h"
  43 #include "media-svc-env.h"
  44 #include "media-svc-hash.h"
  45 #include "media-svc-album.h"
  46
  47
  48 #define MEDIA_SVC_FILE_EXT_LEN_MAX                              6                       /**<  Maximum file ext lenth*/
  49
  50 typedef enum {
  51         MEDIA_SVC_EXTRACTED_FIELD_NONE                  = 0x00000001,
  52         MEDIA_SVC_EXTRACTED_FIELD_TITLE                         = MEDIA_SVC_EXTRACTED_FIELD_NONE << 1,
  53         MEDIA_SVC_EXTRACTED_FIELD_DESC                  = MEDIA_SVC_EXTRACTED_FIELD_NONE << 2,
  54         MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT             = MEDIA_SVC_EXTRACTED_FIELD_NONE << 3,
  55         MEDIA_SVC_EXTRACTED_FIELD_AUTHOR                = MEDIA_SVC_EXTRACTED_FIELD_NONE << 4,
  56         MEDIA_SVC_EXTRACTED_FIELD_ARTIST                        = MEDIA_SVC_EXTRACTED_FIELD_NONE << 5,
  57         MEDIA_SVC_EXTRACTED_FIELD_GENRE                 = MEDIA_SVC_EXTRACTED_FIELD_NONE << 6,
  58         MEDIA_SVC_EXTRACTED_FIELD_ALBUM                 = MEDIA_SVC_EXTRACTED_FIELD_NONE << 7,
  59         MEDIA_SVC_EXTRACTED_FIELD_TRACKNUM              = MEDIA_SVC_EXTRACTED_FIELD_NONE << 8,
  60         MEDIA_SVC_EXTRACTED_FIELD_YEAR                  = MEDIA_SVC_EXTRACTED_FIELD_NONE << 9,
  61         MEDIA_SVC_EXTRACTED_FIELD_CATEGORY              = MEDIA_SVC_EXTRACTED_FIELD_NONE << 10,
  62 } media_svc_extracted_field_e;
  63
  64 #if 0
  65 static char *__year_2_str(int year);
  66
  67 static char *__year_2_str(int year)
  68 {
  69         static char ret[MEDIA_SVC_METADATA_LEN_MAX];
  70
  71         if (year == -1 || year == 0) {
  72                 _strncpy_safe(ret, MEDIA_SVC_TAG_UNKNOWN, MEDIA_SVC_METADATA_LEN_MAX);
  73         } else {
  74                 snprintf(ret, MEDIA_SVC_METADATA_LEN_MAX - 1, "%d", year);
  75         }
  76         return ret;
  77 }
  78 #endif
  79
  80 char *_media_info_generate_uuid(void)
  81 {
  82         uuid_t uuid_value;
  83         static char uuid_unparsed[50];
  84
  85         uuid_generate(uuid_value);
  86         uuid_unparse(uuid_value, uuid_unparsed);
  87
  88         //media_svc_debug("UUID : %s", uuid_unparsed);
  89         return uuid_unparsed;
  90 }
  91
  92 void _strncpy_safe(char *x_dst, const char *x_src, int max_len)
  93 {
  94         if (!x_src || strlen(x_src) == 0) {
  95                 media_svc_error("x_src is NULL");
  96                 return;
  97         }
  98
  99         if (max_len < 1) {
 100                 media_svc_error("length is Wrong");
 101                 return;
 102         }
 103
 104     strncpy(x_dst, x_src, max_len-1);
 105         x_dst[max_len-1] = '\0';
 106 }
 107
 108 int __media_svc_malloc_and_strncpy(char **dst, const char *src)
 109 {
 110         int len = 0;
 111
 112         if (!STRING_VALID(src)) {
 113                 media_svc_error("invalid src");
 114                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 115         }
 116
 117         SAFE_FREE(*dst);
 118
 119         len = strlen(src) + 1;
 120         *dst = malloc(len);
 121
 122         if (*dst == NULL) {
 123                 media_svc_error("malloc failed");
 124                 return MEDIA_INFO_ERROR_INTERNAL;
 125         }
 126
 127         strncpy(*dst, src, len);
 128         char *p = *dst;
 129         p[len - 1] = '\0';
 130
 131         return MEDIA_INFO_ERROR_NONE;
 132 }
 133
 134 static void __media_svc_split_to_double(char *input, double *arr, int *num)
 135 {
 136         char tmp_arr[255] = { 0, };
 137         int len = strlen(input);
 138         int i = 0, idx = 0, tmp_idx = 0;
 139         int is_prev_space = 0;
 140
 141         for (;;) {
 142                 if (input[len - 1] == ' ') {
 143                         len--;
 144                 } else {
 145                         break;
 146                 }
 147         }
 148
 149         for (i = 0; i < len; i++) {
 150                 if (idx > 2) {
 151                         break;
 152                 }
 153
 154                 if (input[i] == ' ') {
 155                         if (is_prev_space == 1) {
 156                                 continue;
 157                         }
 158                         if (idx <= 2) {
 159                                 arr[idx++] = atof(tmp_arr);
 160                         }
 161                         tmp_idx = 0;
 162                         is_prev_space = 1;
 163                         continue;
 164                 }
 165
 166                 tmp_arr[tmp_idx] = input[i];
 167                 tmp_arr[++tmp_idx] = '\0';
 168                 is_prev_space = 0;
 169         }
 170
 171         if (i == len) {
 172                 if (idx <= 2) {
 173                         arr[idx++] = atof(tmp_arr);
 174                 }
 175                 *num = idx;
 176                 return;
 177         } else {
 178                 *num = idx--;
 179                 return;
 180         }
 181 }
 182
 183 static int __media_svc_get_exif_info(ExifData *ed,
 184                                                                                 char *buf,
 185                                                                                 int *i_value,
 186                                                                                 double *d_value,
 187                                                                                 int ifdtype,
 188                                                                                 long tagtype)
 189 {
 190         ExifEntry *entry;
 191         ExifIfd ifd;
 192         ExifTag tag;
 193
 194         if (ed == NULL) {
 195                 //media_svc_debug("ExifData is NULL");
 196                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 197         }
 198
 199         ifd = ifdtype;
 200         tag = tagtype;
 201
 202         entry = exif_data_get_entry(ed, tag);
 203         if (entry) {
 204                 /* Get the contents of the tag in human-readable form */
 205                 if (tag == EXIF_TAG_ORIENTATION ||
 206                                 tag == EXIF_TAG_PIXEL_X_DIMENSION ||
 207                                 tag == EXIF_TAG_PIXEL_Y_DIMENSION) {
 208
 209                         if (i_value == NULL) {
 210                                 media_svc_error("i_value is NULL");
 211                                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 212                         }
 213
 214                         ExifByteOrder mByteOrder = exif_data_get_byte_order(ed);
 215                         short exif_value = exif_get_short(entry->data, mByteOrder);
 216                         //media_svc_debug("%s : %d", exif_tag_get_name_in_ifd(tag,ifd), exif_value);
 217                         *i_value = (int)exif_value;
 218
 219                 } else if (tag == EXIF_TAG_GPS_LATITUDE || tag == EXIF_TAG_GPS_LONGITUDE || tag == EXIF_TAG_GPS_ALTITUDE) {
 220
 221                         if (d_value == NULL) {
 222                                 media_svc_error("d_value is NULL");
 223                                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 224                         }
 225
 226                         /* Get the contents of the tag in human-readable form */
 227                         char gps_buf[MEDIA_SVC_METADATA_LEN_MAX + 1] = { '\0' };
 228                         exif_entry_get_value(entry, gps_buf, sizeof(gps_buf));
 229                         gps_buf[strlen(gps_buf)] = '\0';
 230
 231                         //media_svc_debug("%s: %s\n", exif_tag_get_name_in_ifd(tag, ifd), gps_buf);
 232
 233                         double tmp_arr[3] = { 0.0, 0.0, 0.0 };
 234                         int count = 0;
 235
 236                         __media_svc_split_to_double(gps_buf, tmp_arr, &count);
 237                         if (count != 3) {
 238                                 media_svc_error("Value is invalid");
 239                                 return MEDIA_INFO_ERROR_INTERNAL;
 240                         }
 241
 242                         *d_value = tmp_arr[0] + tmp_arr[1] / 60 + tmp_arr[2] / 3600;
 243                         //media_svc_debug("GPS value is %f", *d_value);
 244                 } else {
 245
 246                         if (buf == NULL) {
 247                                 media_svc_error("buf is NULL");
 248                                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 249                         }
 250
 251                         exif_entry_get_value(entry, buf, MEDIA_SVC_METADATA_LEN_MAX);
 252                         buf[strlen(buf)] = '\0';
 253
 254                         if (*buf) {
 255                                 media_svc_debug("%s: %s\n", exif_tag_get_name_in_ifd(tag, ifd), buf);
 256                         }
 257                 }
 258         }
 259
 260         return MEDIA_INFO_ERROR_NONE;
 261 }
 262
 263 unsigned int _media_svc_get_current_time(void)
 264 {
 265         struct timeval  t;
 266         unsigned int tval = 0;
 267         gettimeofday(&t, NULL);
 268
 269         tval = t.tv_sec*1000000L + t.tv_usec;
 270
 271         return tval/1000;
 272 }
 273
 274 int _media_svc_check_escape_char(char ch)
 275 {
 276         int i;
 277         char escape_char[3] = {'%', '_' ,'#'};
 278
 279         for (i = 0; i < 3; i++) {
 280                 if (ch == escape_char[i]) {
 281                         return 1;
 282                 }
 283         }
 284
 285         return 0;
 286 }
 287
 288 char *_media_svc_escape_str(char *input, int len)
 289 {
 290         int i = 0;
 291         int j = 0;
 292         char *result = NULL;
 293
 294         result = (char*)malloc(len * 2 * sizeof(char) + 1);
 295         if (result == NULL) {
 296                 return NULL;
 297         }
 298
 299         for (i = 0; i < len; i++, j++) {
 300                 if (input[i] == '\0') break;
 301
 302                 if (_media_svc_check_escape_char(input[i])) {
 303                         result[j] = '#';
 304                         result[++j] = input[i];
 305                 } else {
 306                         result[j] = input[i];
 307                 }
 308         }
 309
 310         result[j] = '\0';
 311
 312         return result;
 313 }
 314
 315 int _media_svc_rename_file( const char *old_name, const char *new_name)
 316 {
 317         if((old_name == NULL) || (new_name == NULL))
 318         {
 319                 media_svc_error("invalid file name");
 320                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 321         }
 322
 323         if (rename(old_name, new_name) < 0) {
 324                 media_svc_error("Old : [%s] New : [%s] errno : [%s]", old_name, new_name, strerror(errno));
 325                 return MEDIA_INFO_ERROR_INTERNAL;
 326         }
 327
 328         return MEDIA_INFO_ERROR_NONE;
 329 }
 330
 331 bool _media_svc_remove_file(const char *path)
 332 {
 333         int result = -1;
 334
 335         result = remove(path);
 336         if (result == 0) {
 337                 media_svc_debug("success to remove file");
 338                 return TRUE;
 339         } else {
 340                 media_svc_error("fail to remove file result errno = %s", strerror(errno));
 341                 return FALSE;
 342         }
 343 }
 344
 345 int _media_svc_remove_all_files_in_dir(const char *dir_path)
 346 {
 347         struct dirent *entry = NULL;
 348         struct stat st;
 349         char filename[MEDIA_SVC_PATHNAME_SIZE] = {0};
 350         DIR *dir = NULL;
 351
 352         dir = opendir(dir_path);
 353         if (dir == NULL) {
 354                 media_svc_error("%s is not exist", dir_path);
 355                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 356         }
 357
 358         while ((entry = readdir(dir)) != NULL) {
 359                 if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
 360                         continue;
 361                 }
 362                 snprintf(filename, sizeof(filename), "%s/%s", dir_path, entry->d_name);
 363
 364                 if (stat(filename, &st) != 0) {
 365                         continue;
 366                 }
 367                 if (S_ISDIR(st.st_mode)) {
 368                         continue;
 369                 }
 370                 if (unlink(filename) != 0) {
 371                         media_svc_error("failed to remove : %s", filename);
 372                         closedir(dir);
 373                         return MEDIA_INFO_ERROR_INTERNAL;
 374                 }
 375         }
 376
 377         closedir(dir);
 378         return MEDIA_INFO_ERROR_NONE;
 379 }
 380
 381 char *_media_svc_get_title_from_filepath (const char *path)
 382 {
 383         char *filename = NULL;
 384         char *title = NULL;
 385         char    *ext = NULL;
 386         int filename_len = -1;
 387         int new_title_len = -1;
 388
 389         if (!path) {
 390                 media_svc_error("path is NULL");
 391                 return NULL;
 392         }
 393
 394         filename = g_path_get_basename(path);
 395         if (!STRING_VALID(filename)) {
 396                 media_svc_error("wrong file name");
 397                 SAFE_FREE(filename);
 398                 return NULL;
 399         }
 400
 401         filename_len = strlen(filename);
 402
 403         ext = g_strrstr(filename, ".");
 404         if (!ext) {
 405                 media_svc_error("there is no file extention");
 406                 return filename;
 407         }
 408
 409         new_title_len = filename_len - strlen(ext);
 410         if (new_title_len < 1) {
 411                 media_svc_error("title length is zero");
 412                 SAFE_FREE(filename);
 413                 return NULL;
 414         }
 415
 416         title = g_strndup(filename, new_title_len < MEDIA_SVC_PATHNAME_SIZE ? new_title_len : MEDIA_SVC_PATHNAME_SIZE-1);
 417
 418         SAFE_FREE(filename);
 419
 420         media_svc_debug("extract title is [%s]", title);
 421
 422         return title;
 423 }
 424
 425 int _media_svc_save_image(void *image, int size, char *image_path)
 426 {
 427         media_svc_debug("start save image, path [%s] image size [%d]", image_path, size);
 428
 429         if (!image) {
 430                 media_svc_error("invalid image..");
 431                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         struct statfs fs;
 435         if (-1 == statfs(MEDIA_SVC_THUMB_PATH_PREFIX, &fs)) {
 436                 media_svc_error("error in statfs");
 437                 return MEDIA_INFO_ERROR_INTERNAL;
 438         }
 439
 440         long bsize_kbytes = fs.f_bsize >> 10;
 441
 442         if ((bsize_kbytes * fs.f_bavail) < 1024) {
 443                 media_svc_error("not enought space...");
 444                 return MEDIA_INFO_ERROR_INTERNAL;
 445         }
 446
 447         FILE *fp = NULL;
 448         int nwrite = -1;
 449         if (image != NULL && size > 0) {
 450                 fp = fopen(image_path, "w");
 451
 452                 if (fp == NULL) {
 453                         media_svc_error("failed to open file");
 454                         return MEDIA_INFO_ERROR_INTERNAL;
 455                 }
 456
 457                 nwrite = fwrite(image, 1, size, fp);
 458                 if (nwrite != size) {
 459                         media_svc_error("failed to write thumbnail");
 460                         fclose(fp);
 461                         return MEDIA_INFO_ERROR_INTERNAL;
 462                 }
 463                 fclose(fp);
 464         }
 465
 466         return MEDIA_INFO_ERROR_NONE;
 467 }
 468
 469 bool _media_svc_get_thumbnail_path(media_svc_storage_type_e storage_type, char *thumb_path, const char *pathname, const char *img_format)
 470 {
 471         char savename[MEDIA_SVC_PATHNAME_SIZE] = {0};
 472         char file_ext[MEDIA_SVC_FILE_EXT_LEN_MAX + 1] = {0};
 473         char *thumb_dir = NULL;
 474         char hash[255 + 1];
 475         char *thumbfile_ext = NULL;
 476
 477         thumb_dir = (storage_type == MEDIA_SVC_STORAGE_INTERNAL) ? MEDIA_SVC_THUMB_INTERNAL_PATH : MEDIA_SVC_THUMB_EXTERNAL_PATH;
 478
 479         memset(file_ext, 0, sizeof(file_ext));
 480         if (!_media_svc_get_file_ext(pathname, file_ext)) {
 481                 media_svc_error("get file ext fail");
 482         }
 483
 484         int err = -1;
 485         err = mb_svc_generate_hash_code(pathname, hash, sizeof(hash));
 486         if (err < 0) {
 487                 media_svc_error("mb_svc_generate_hash_code failed : %d", err);
 488                 return FALSE;
 489         }
 490
 491         //media_svc_debug("img format is [%s]", img_format);
 492
 493         if((strstr(img_format, "jpeg") != NULL) ||(strstr(img_format, "jpg") != NULL) ||(strstr(img_format, "JPG") != NULL)) {
 494                 thumbfile_ext = "jpg";
 495         } else if((strstr(img_format, "png") != NULL) ||(strstr(img_format, "PNG") != NULL)) {
 496                 thumbfile_ext = "png";
 497         } else if((strstr(img_format, "gif") != NULL) ||(strstr(img_format, "GIF") != NULL)) {
 498                 thumbfile_ext = "gif";
 499         } else if((strstr(img_format, "bmp") != NULL) ||(strstr(img_format, "BMP") != NULL)) {
 500                 thumbfile_ext = "bmp";
 501         } else {
 502                 media_svc_error("Not proper img format");
 503                 return FALSE;
 504         }
 505
 506         snprintf(savename, sizeof(savename), "%s/.%s-%s.%s", thumb_dir, file_ext, hash, thumbfile_ext);
 507         _strncpy_safe(thumb_path, savename, MEDIA_SVC_PATHNAME_SIZE);
 508         //media_svc_debug("thumb_path is [%s]", thumb_path);
 509
 510         return TRUE;
 511 }
 512
 513 bool _media_svc_get_file_ext(const char *file_path, char *file_ext)
 514 {
 515         int i = 0;
 516
 517         for (i = strlen(file_path); i >= 0; i--) {
 518                 if (file_path[i] == '.') {
 519                         _strncpy_safe(file_ext, &file_path[i+1], MEDIA_SVC_FILE_EXT_LEN_MAX);
 520                         return true;
 521                 }
 522
 523                 if (file_path[i] == '/') {
 524                         return false;
 525                 }
 526         }
 527         return false;
 528 }
 529
 530 int _media_svc_get_file_time(const char *full_path)
 531 {
 532         struct stat statbuf;
 533         int fd = 0;
 534
 535         memset(&statbuf, 0, sizeof(struct stat));
 536         fd = stat(full_path, &statbuf);
 537         if (fd == -1) {
 538                  media_svc_error("stat(%s) fails.", full_path);
 539                  return MEDIA_INFO_ERROR_INTERNAL;
 540          }
 541
 542          return statbuf.st_mtime;
 543 }
 544
 545 int _media_svc_set_media_info(media_svc_content_info_s *content_info, media_svc_storage_type_e storage_type,
 546                           const char *path, media_svc_media_type_e *media_type, bool refresh, drm_content_info_s **drm_contentInfo)
 547 {
 548         int ret = MEDIA_INFO_ERROR_NONE;
 549         char * media_uuid = NULL;
 550         char * file_name = NULL;
 551         struct stat st;
 552         drm_bool_type_e drm_type = DRM_FALSE;
 553         char mime_type[256] = {0};
 554
 555         ret = __media_svc_malloc_and_strncpy(&content_info->path, path);
 556         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 557
 558         memset(&st, 0, sizeof(struct stat));
 559         if (stat(path, &st) == 0) {
 560                 content_info->modified_time = st.st_mtime;
 561                 content_info->size = st.st_size;
 562                 //media_svc_debug("Modified time : [%d] Size : [%lld]", content_info->modified_time, content_info->size);
 563         } else {
 564                 media_svc_error("stat failed : %s", strerror(errno));
 565         }
 566
 567         /* Set default GPS value before extracting meta information */
 568         content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 569         content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 570         content_info->media_meta.altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 571
 572         /* Set default value before extracting meta information */
 573         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
 574         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 575
 576         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
 577         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 578
 579         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, MEDIA_SVC_TAG_UNKNOWN);
 580         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 581
 582         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, MEDIA_SVC_TAG_UNKNOWN);
 583         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 584
 585         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
 586         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 587
 588         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
 589         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 590
 591         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
 592         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 593
 594         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
 595         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 596
 597         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
 598         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 599
 600         /* refresh is TRUE when file modified. so only modified_time and size are changed*/
 601         if(refresh) {
 602                 media_svc_debug("refresh");
 603                 return MEDIA_INFO_ERROR_NONE;
 604         }
 605
 606         content_info->storage_type = storage_type;
 607         time(&content_info->added_time);
 608
 609         media_uuid = _media_info_generate_uuid();
 610         media_svc_retvm_if(media_uuid == NULL, MEDIA_INFO_ERROR_INTERNAL, "Invalid UUID");
 611
 612         ret = __media_svc_malloc_and_strncpy(&content_info->media_uuid, media_uuid);
 613         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 614
 615         file_name = g_path_get_basename(path);
 616         ret = __media_svc_malloc_and_strncpy(&content_info->file_name, file_name);
 617         SAFE_FREE(file_name);
 618         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 619
 620         /* if the file is DRM file, drm_type value is DRM_TRUE(1).
 621         if drm_contentinfo is not NULL, the file is OMA DRM.*/
 622         ret = _media_svc_get_mime_type(path, mime_type, &drm_type, drm_contentInfo);
 623         if (ret < 0) {
 624                 media_svc_error("media_svc_get_mime_type failed : %d (%s)", ret, path);
 625                 return MEDIA_INFO_ERROR_INVALID_PATH;
 626         }
 627
 628         media_svc_error("mime [%s]", mime_type);
 629         content_info->is_drm = drm_type;
 630
 631         ret = _media_svc_get_media_type(path, mime_type, media_type);
 632         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 633         if ((*media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (*media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
 634                 media_svc_error("invalid media_type condition[%d]", *media_type);
 635                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 636         }
 637
 638         ret = __media_svc_malloc_and_strncpy(&content_info->mime_type, mime_type);
 639         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 640
 641         media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, *media_type);
 642
 643         content_info->media_type = *media_type;
 644
 645         content_info->played_count = 0;
 646         content_info->last_played_time= 0;
 647         content_info->last_played_position= 0;
 648         content_info->favourate= 0;
 649         content_info->media_meta.rating = 0;
 650
 651         return MEDIA_INFO_ERROR_NONE;
 652 }
 653
 654 int _media_svc_extract_image_metadata(media_svc_content_info_s *content_info, media_svc_media_type_e media_type)
 655 {
 656         if (content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 657                 media_svc_error("content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE");
 658                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 659         }
 660
 661         char buf[MEDIA_SVC_METADATA_LEN_MAX + 1] = { '\0' };
 662         char description_buf[MEDIA_SVC_METADATA_DESCRIPTION_MAX + 1] = { '\0' };
 663         memset(buf, 0x00, sizeof(buf));
 664         memset(description_buf, 0x00, sizeof(description_buf));
 665
 666         int ret = MEDIA_INFO_ERROR_NONE;
 667         double value = 0.0;
 668         int orient_value = 0;
 669         int exif_width = 0;
 670         int exif_height = 0;
 671         ExifData *ed = NULL;
 672
 673         char *path = content_info->path;
 674         if (path == NULL) {
 675                 media_svc_error("path is NULL");
 676                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 677         }
 678
 679         /* Load an ExifData object from an EXIF file */
 680         ed = exif_data_new_from_file(path);
 681
 682         if (!ed) {
 683                 media_svc_debug("There is no exif data in [ %s ]", path);
 684         }
 685
 686         if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LATITUDE_REF) == MEDIA_INFO_ERROR_NONE) {
 687                 if (strlen(buf) != 0) {
 688                         if (__media_svc_get_exif_info(ed, NULL, NULL, &value, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE) == MEDIA_INFO_ERROR_NONE) {
 689
 690                                 if (strcmp(buf, "S") == 0) {
 691                                         value = -1 * value;
 692                                 }
 693
 694                                 content_info->media_meta.latitude = value;
 695                         } else {
 696                                 content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 697                         }
 698                 } else {
 699                         content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 700                 }
 701         } else {
 702                 content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 703         }
 704
 705         memset(buf, 0x00, sizeof(buf));
 706
 707         if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LONGITUDE_REF) == MEDIA_INFO_ERROR_NONE) {
 708                 if (strlen(buf) != 0) {
 709                         if (__media_svc_get_exif_info(ed, NULL, NULL, &value, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE) == MEDIA_INFO_ERROR_NONE) {
 710                                 if (strcmp(buf, "W") == 0) {
 711                                         value = -1 * value;
 712                                 }
 713                                 content_info->media_meta.longitude = value;
 714                         } else {
 715                                 content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 716                         }
 717                 } else {
 718                         content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 719                 }
 720         } else {
 721                 content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 722         }
 723
 724         memset(buf, 0x00, sizeof(buf));
 725
 726         if (__media_svc_get_exif_info(ed, description_buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION) == MEDIA_INFO_ERROR_NONE) {
 727                 if (strlen(description_buf) == 0) {
 728                         //media_svc_debug("Use 'No description'");
 729                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
 730                         if(ret != MEDIA_INFO_ERROR_NONE)
 731                                 media_svc_error("strcpy error");
 732                 } else {
 733                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, description_buf);
 734                         if(ret != MEDIA_INFO_ERROR_NONE)
 735                                 media_svc_error("strcpy error");
 736                 }
 737         } else {
 738                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
 739                 if(ret != MEDIA_INFO_ERROR_NONE)
 740                         media_svc_error("strcpy error");
 741         }
 742
 743         memset(buf, 0x00, sizeof(buf));
 744
 745         if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_DATE_TIME) == MEDIA_INFO_ERROR_NONE) {
 746                 if (strlen(buf) == 0) {
 747                         //media_svc_debug("time  is NULL");
 748                 } else {
 749                         //media_svc_debug("time  is %s", buf);
 750                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.datetaken, buf);
 751                         if(ret != MEDIA_INFO_ERROR_NONE)
 752                                 media_svc_error("strcpy error");
 753                 }
 754         }
 755
 756         /* Get orientation value from exif. */
 757         if (__media_svc_get_exif_info(ed, NULL, &orient_value, NULL, EXIF_IFD_0, EXIF_TAG_ORIENTATION) == MEDIA_INFO_ERROR_NONE) {
 758                 if (orient_value >= NOT_AVAILABLE && orient_value <= ROT_270) {
 759                         content_info->media_meta.orientation = orient_value;
 760                 } else {
 761                         content_info->media_meta.orientation = 0;
 762                 }
 763         } else {
 764                 content_info->media_meta.orientation = 0;
 765         }
 766
 767         /* Get width value from exif. */
 768         if (__media_svc_get_exif_info(ed, NULL, &exif_width, NULL, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION) == MEDIA_INFO_ERROR_NONE) {
 769                 if (exif_width > 0) {
 770                         content_info->media_meta.width = exif_width;
 771                 } else {
 772                         content_info->media_meta.width = 0;
 773                 }
 774         } else {
 775                 content_info->media_meta.width = 0;
 776         }
 777
 778         /* Get height value from exif. */
 779         if (__media_svc_get_exif_info(ed, NULL, &exif_height, NULL, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION) == MEDIA_INFO_ERROR_NONE) {
 780                 if (exif_height > 0) {
 781                         content_info->media_meta.height = exif_height;
 782                 } else {
 783                         content_info->media_meta.height = 0;
 784                 }
 785         } else {
 786                 content_info->media_meta.height = 0;
 787         }
 788
 789         if (ed != NULL) exif_data_unref(ed);
 790 #if 0
 791         /* Extracting thumbnail */
 792         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 793         int width = 0;
 794         int height = 0;
 795
 796         ret = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
 797         if (ret < 0) {
 798                 media_svc_error("thumbnail_request_from_db failed: %d", ret);
 799         } else {
 800                 //media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 801         }
 802
 803         content_info->media_meta.width = width;
 804         content_info->media_meta.height = height;
 805
 806         if (STRING_VALID(thumb_path))
 807                 ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
 808         else
 809                 content_info->thumbnail_path = NULL;
 810
 811         if(ret != MEDIA_INFO_ERROR_NONE)
 812                 media_svc_error("strcpy error");
 813 #endif
 814         return MEDIA_INFO_ERROR_NONE;
 815 }
 816
 817 int _media_svc_extract_media_metadata(sqlite3 *handle, media_svc_content_info_s *content_info, media_svc_media_type_e media_type, drm_content_info_s *drm_contentInfo)
 818 {
 819         MMHandleType content = 0;
 820         MMHandleType tag = 0;
 821         char *p = NULL;
 822         void *image = NULL;
 823         int size = -1;
 824         int extracted_field = MEDIA_SVC_EXTRACTED_FIELD_NONE;
 825         int mmf_error = MM_ERROR_NONE;
 826         bool thumb_extracted_from_drm = FALSE;
 827         char *err_attr_name = NULL;
 828         char *title = NULL;
 829         bool extract_thumbnail = FALSE;
 830         bool append_album = FALSE;
 831         int album_id = 0;
 832         double gps_value = 0.0;
 833         int ret = MEDIA_INFO_ERROR_NONE;
 834         char *path = content_info->path;
 835
 836         /*To do - code for DRM content*/
 837         if (content_info->is_drm) {
 838                 drm_file_type_e drm_file_type;
 839
 840                 ret = drm_get_file_type(path, &drm_file_type);
 841                 if (ret < 0) {
 842                         media_svc_error("drm_get_file_type falied : %d", ret);
 843                         drm_file_type = DRM_TYPE_UNDEFINED;
 844                 }
 845
 846                 /* if drm_contentinfo is not NULL, the file is OMA DRM.*/
 847                 if (drm_contentInfo != NULL) {
 848                         if (drm_file_type == DRM_TYPE_OMA_V1) {
 849                                 if (strlen(drm_contentInfo->title) > 0) {
 850                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, drm_contentInfo->title);
 851                                         if(ret != MEDIA_INFO_ERROR_NONE)
 852                                                 media_svc_error("strcpy error");
 853                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
 854                                 }
 855
 856                                 if (strlen(drm_contentInfo->description) > 0) {
 857                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, drm_contentInfo->description);
 858                                         if(ret != MEDIA_INFO_ERROR_NONE)
 859                                                 media_svc_error("strcpy error");
 860                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
 861                                 }
 862                         } else if (drm_file_type == DRM_TYPE_OMA_V2) {
 863                                 if (strlen(drm_contentInfo->title) > 0) {
 864                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, drm_contentInfo->title);
 865                                         if(ret != MEDIA_INFO_ERROR_NONE)
 866                                                 media_svc_error("strcpy error");
 867                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
 868                                 }
 869
 870                                 if (strlen(drm_contentInfo->description) > 0) {
 871                                         ret =  __media_svc_malloc_and_strncpy(&content_info->media_meta.description, drm_contentInfo->description);
 872                                         if(ret != MEDIA_INFO_ERROR_NONE)
 873                                                 media_svc_error("strcpy error");
 874                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
 875                                 }
 876
 877                                 if (strlen(drm_contentInfo->copyright) > 0) {
 878                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, drm_contentInfo->copyright);
 879                                         if(ret != MEDIA_INFO_ERROR_NONE)
 880                                                 media_svc_error("strcpy error");
 881                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT;
 882                                 }
 883
 884                                 if (strlen(drm_contentInfo->author) > 0) {
 885                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, drm_contentInfo->author);
 886                                         if(ret != MEDIA_INFO_ERROR_NONE)
 887                                                 media_svc_error("strcpy error");
 888                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, drm_contentInfo->author);
 889                                         if(ret != MEDIA_INFO_ERROR_NONE)
 890                                                 media_svc_error("strcpy error");
 891
 892                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
 893                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ARTIST;
 894                                 }
 895                         }
 896
 897                         if (!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) {
 898                                 title = _media_svc_get_title_from_filepath(path);
 899                                 if (title) {
 900                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
 901                                         SAFE_FREE(title);
 902                                         if(ret != MEDIA_INFO_ERROR_NONE)
 903                                                 media_svc_error("strcpy error");
 904                                 } else {
 905                                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
 906                                 }
 907                         }
 908
 909                         return MEDIA_INFO_ERROR_NONE;
 910                 } else {
 911                         media_svc_debug("Some Not OMA Content's metadata is not incrypted so fileinfo can extracted metadata");
 912                 }
 913         }
 914
 915 #if 0
 916         if (drm_svc_is_drm_file(content_info->path)) {
 917                 bool invalid_file = FALSE;
 918
 919                 DRM_FILE_TYPE type = drm_svc_get_drm_type(content_info->path);
 920
 921                 if (type == DRM_FILE_TYPE_OMA) {
 922                         drm_dcf_header_t header_info;
 923                         memset(&header_info, 0, sizeof(drm_dcf_header_t));
 924                         media_svc_debug("drm type is OMA");
 925
 926                         if (drm_svc_get_dcf_header_info(content_info->path, &header_info) != DRM_RESULT_SUCCESS) {
 927                                 media_svc_debug("cannot get dcf header info. just get the title");
 928                                 title = _media_svc_get_title_from_filepath(content_info->path);
 929                                 if (title) {
 930                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
 931                                         SAFE_FREE(title);
 932                                         media_svc_retv_del_if(ret < 0, ret, content_info);
 933                                         //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
 934                                 } else {
 935                                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
 936                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
 937                                         media_svc_retv_del_if(ret < 0, ret, content_info);
 938                                 }
 939
 940 /*
 941                                 _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
 942                                 _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
 943                                 _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
 944                                 _strncpy_safe(content_info->media_meta.author, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.author));
 945                                 _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
 946 */
 947
 948                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
 949                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 950                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
 951                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 952                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
 953                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 954                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
 955                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 956                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
 957                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 958
 959                                 return MEDIA_INFO_ERROR_NONE;
 960                         }
 961
 962                         if (drm_svc_has_valid_ro(content_info->path, DRM_PERMISSION_PLAY) != DRM_RESULT_SUCCESS) {
 963                                 media_svc_debug("no valid ro. can't extract meta data");
 964                                 invalid_file = TRUE;
 965                         }
 966
 967                         if (header_info.version == DRM_OMA_DRMV1_RIGHTS) {
 968                                 media_svc_debug("DRM V1");
 969                                 if (invalid_file) {
 970
 971                                         if (strlen(header_info.headerUnion.headerV1.contentName) > 0) {
 972
 973                                                 //_strncpy_safe(content_info->media_meta.title, header_info.headerUnion.headerV1.contentName, sizeof(content_info->media_meta.title));
 974                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, header_info.headerUnion.headerV1.contentName);
 975                                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 976
 977                                                 extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
 978                                                 media_svc_debug("extract title from DCF");
 979                                         }
 980
 981                                         if (strlen(header_info.headerUnion.headerV1.contentDescription) > 0) {
 982                                                 //_strncpy_safe(content_info->media_meta.description, header_info.headerUnion.headerV1.contentDescription, sizeof(content_info->media_meta.description));
 983                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, header_info.headerUnion.headerV1.contentDescription);
 984                                                 media_svc_retv_del_if(ret < 0, ret, content_info);
 985
 986                                                 extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
 987                                                 media_svc_debug("extract description from DCF");
 988                                         }
 989                                 }
 990                         } else if (header_info.version == DRM_OMA_DRMV2_RIGHTS) {
 991                                 drm_user_data_common_t metadata;
 992                                 int type_index = -1;
 993
 994                                 media_svc_debug("DRM V2");
 995
 996                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_TITLE, &metadata) == DRM_RESULT_SUCCESS) {
 997                                         //_strncpy_safe(content_info->media_meta.title, metadata.subBox.title.str, sizeof(content_info->media_meta.title));
 998                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, metadata.subBox.title.str);
 999                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1000
1001                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
1002                                         media_svc_debug("extract title from odf");
1003                                 }
1004
1005                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_DESCRIPTION, &metadata) == DRM_RESULT_SUCCESS) {
1006                                         //_strncpy_safe(content_info->media_meta.description, metadata.subBox.desc.str, sizeof(content_info->media_meta.description));
1007                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, metadata.subBox.desc.str);
1008                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1009
1010                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
1011                                 }
1012
1013                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_COPYRIGHT, &metadata) == DRM_RESULT_SUCCESS) {
1014                                         //_strncpy_safe(content_info->media_meta.copyright, metadata.subBox.copyright.str, sizeof(content_info->media_meta.copyright));
1015                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, metadata.subBox.copyright.str);
1016                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1017
1018                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT;
1019                                 }
1020
1021                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_AUTHOR, &metadata) == DRM_RESULT_SUCCESS) {
1022                                         //_strncpy_safe(content_info->media_meta.composer, metadata.subBox.author.str, sizeof(content_info->media_meta.composer));
1023                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, metadata.subBox.author.str);
1024                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1025
1026                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
1027                                 }
1028
1029                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_PERFORMER, &metadata) == DRM_RESULT_SUCCESS) {
1030                                         //_strncpy_safe(content_info->media_meta.artist, metadata.subBox.performer.str, sizeof(content_info->media_meta.artist));
1031                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, metadata.subBox.performer.str);
1032                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1033
1034                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ARTIST;
1035                                 }
1036
1037                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_GENRE, &metadata) == DRM_RESULT_SUCCESS) {
1038                                         //_strncpy_safe(content_info->media_meta.genre, metadata.subBox.genre.str, sizeof(content_info->media_meta.genre));
1039                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, metadata.subBox.genre.str);
1040                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1041
1042                                         //media_svc_debug("genre : %s", content_info->media_meta.genre);
1043                                         /* If genre is Ringtone, it's categorized as sound. But this logic is commented */
1044                                         /*
1045                                         if ((strcasecmp("Ringtone", metadata.subBox.genre.str) == 0) | (strcasecmp("Alert tone", metadata.subBox.genre.str) == 0)) {
1046                                                 content_info->media_type = MEDIA_SVC_MEDIA_TYPE_SOUND;
1047                                         }
1048                                         */
1049                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_GENRE;
1050                                 }
1051
1052                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_ALBUM, &metadata) == DRM_RESULT_SUCCESS) {
1053                                         //_strncpy_safe(content_info->media_meta.album, metadata.subBox.album.albumTitle, sizeof(content_info->media_meta.album));
1054                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, metadata.subBox.album.albumTitle);
1055                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1056
1057                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ALBUM;
1058
1059                                         char track_num[MEDIA_SVC_METADATA_LEN_MAX] = {0,};
1060                                         snprintf(track_num, sizeof(track_num), "%d", metadata.subBox.album.trackNum);
1061
1062                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, track_num);
1063                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1064
1065                                         //snprintf(content_info->media_meta.track_num, MEDIA_SVC_METADATA_LEN_MAX, "%d", metadata.subBox.album.trackNum);
1066                                 }
1067
1068                                 if (drm_svc_get_user_data_box_info(content_info->path, DRM_UDTA_RECODINGYEAR, &metadata) == DRM_RESULT_SUCCESS) {
1069                                         //_strncpy_safe(content_info->media_meta.year, __year_2_str(metadata.subBox.recodingYear.recodingYear), sizeof(content_info->media_meta.year));
1070                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, __year_2_str(metadata.subBox.recodingYear.recodingYear));
1071                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1072
1073                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_YEAR;
1074                                 }
1075
1076                                 if (drm_svc_get_index_of_relative_contents(content_info->path, DRM_CONTENTS_INDEX_ALBUMJACKET, &type_index) == DRM_RESULT_SUCCESS) {
1077                                         char thumb_path[MEDIA_SVC_PATHNAME_SIZE+1] = {0};
1078
1079                                         if (drm_svc_make_multipart_drm_full_path(content_info->path, type_index, MEDIA_SVC_PATHNAME_SIZE, thumb_path) == DRM_TRUE) {
1080
1081                                                 DRM_FILE_HANDLE hFile = DRM_HANDLE_NULL;
1082
1083                                                 media_svc_debug("drm image path : %s", thumb_path);
1084
1085                                                 if (drm_svc_open_file(thumb_path, DRM_PERMISSION_ANY, &hFile) == DRM_RESULT_SUCCESS) {
1086                                                         int thumb_size = 0;
1087
1088                                                         if (drm_svc_seek_file(hFile, 0, DRM_SEEK_END) != DRM_RESULT_SUCCESS) {
1089                                                                 goto DRM_SEEK_ERROR;
1090                                                         }
1091                                                         thumb_size = drm_svc_tell_file(hFile);
1092
1093                                                         if (drm_svc_seek_file(hFile, 0, DRM_SEEK_SET) != DRM_RESULT_SUCCESS) {
1094                                                                 goto DRM_SEEK_ERROR;
1095                                                         }
1096                                                         /* remove thumbnail extract routine in db creating time.
1097                                                         media_svc_debug("drm thumb size : %d", thumb_size);
1098                                                         if (thumb_size > 0) {
1099                                                                 unsigned int readSize = 0;
1100
1101                                                                 thumb_buffer = malloc(thumb_size);
1102                                                                 if (drm_svc_read_file(hFile, thumb_buffer,thumb_size, &readSize) != DRM_RESULT_SUCCESS) {
1103                                                                         SAFE_FREE(thumb_buffer);
1104                                                                         goto DRM_SEEK_ERROR;
1105                                                                 }
1106
1107                                                                 __save_thumbnail(thumb_buffer, readSize, 1, content_info);
1108                                                                 SAFE_FREE(thumb_buffer);
1109                                                                 thumb_extracted_from_drm = TRUE;
1110                                                         }
1111                                                         */
1112                                                         DRM_SEEK_ERROR:
1113                                                                 drm_svc_free_dcf_header_info(&header_info);
1114                                                                 drm_svc_close_file(hFile);
1115                                                 }
1116                                         }
1117                                 }
1118                         } else {
1119                                 media_svc_debug("unsupported drm format");
1120                                 drm_svc_free_dcf_header_info(&header_info);
1121                                 title = _media_svc_get_title_from_filepath(content_info->path);
1122                                 if (title) {
1123                                         //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
1124                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1125                                         SAFE_FREE(title);
1126                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1127
1128                                 } else {
1129                                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1130                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
1131                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1132                                 }
1133
1134                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
1135                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1136                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
1137                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1138                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
1139                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1140                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
1141                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1142                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
1143                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1144 /*
1145                                 _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
1146                                 _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
1147                                 _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
1148                                 _strncpy_safe(content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.composer));
1149                                 _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
1150 */
1151                                 return MEDIA_INFO_ERROR_NONE;
1152                         }
1153
1154                         if (invalid_file == TRUE) {
1155                                 if (!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) {
1156                                         title = _media_svc_get_title_from_filepath(content_info->path);
1157                                         if (title) {
1158                                                 //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
1159                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1160                                                 SAFE_FREE(title);
1161                                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1162
1163                                                 extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
1164                                         } else {
1165                                                 media_svc_error("Can't extract title from filepath");
1166                                                 drm_svc_free_dcf_header_info(&header_info);
1167                                                 return MEDIA_INFO_ERROR_INTERNAL;
1168                                         }
1169
1170                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
1171                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1172                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
1173                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1174                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
1175                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1176                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
1177                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1178                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
1179                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1180 /*
1181                                         _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
1182                                         _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
1183                                         _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
1184                                         _strncpy_safe(content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.composer));
1185                                         _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
1186 */
1187                                 }
1188
1189                                 drm_svc_free_dcf_header_info(&header_info);
1190                                 return MEDIA_INFO_ERROR_NONE;
1191                         }
1192                 } else if (type == DRM_FILE_TYPE_PLAYREADY) {
1193                         media_svc_debug("drm type is PLAYREADY");
1194                         if (drm_svc_has_valid_ro(content_info->path, DRM_PERMISSION_PLAY) != DRM_RESULT_SUCCESS) {
1195                                 media_svc_debug("no valid ro. can't extract meta data");
1196                                 title = _media_svc_get_title_from_filepath(content_info->path);
1197                                 if (title) {
1198                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1199                                         SAFE_FREE(title);
1200                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1201                                         //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
1202                                 } else {
1203                                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1204                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
1205                                         media_svc_retv_del_if(ret < 0, ret, content_info);
1206                                 }
1207
1208                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
1209                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1210                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
1211                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1212                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
1213                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1214                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
1215                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1216                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
1217                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1218 /*
1219                                 _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
1220                                 _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
1221                                 _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
1222                                 _strncpy_safe(content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.composer));
1223                                 _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
1224 */
1225
1226                                 return MEDIA_INFO_ERROR_NONE;
1227                         }
1228                 } else {
1229                         media_svc_error("Not supported DRM type");
1230                         title = _media_svc_get_title_from_filepath(content_info->path);
1231                         if (title) {
1232                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1233                                 SAFE_FREE(title);
1234                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1235                                 //_strncpy_safe(content_info->media_meta.title, title, sizeof(content_info->media_meta.title));
1236                         } else {
1237                                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1238                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
1239                                 media_svc_retv_del_if(ret < 0, ret, content_info);
1240                         }
1241
1242                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
1243                         media_svc_retv_del_if(ret < 0, ret, content_info);
1244                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
1245                         media_svc_retv_del_if(ret < 0, ret, content_info);
1246                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
1247                         media_svc_retv_del_if(ret < 0, ret, content_info);
1248                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
1249                         media_svc_retv_del_if(ret < 0, ret, content_info);
1250                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
1251                         media_svc_retv_del_if(ret < 0, ret, content_info);
1252 /*
1253                         _strncpy_safe(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.album));
1254                         _strncpy_safe(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.artist));
1255                         _strncpy_safe(content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.genre));
1256                         _strncpy_safe(content_info->media_meta.author, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.author));
1257                         _strncpy_safe(content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN, sizeof(content_info->media_meta.year));
1258 */
1259                         return MEDIA_INFO_ERROR_NONE;
1260                 }
1261         }
1262 #endif
1263         /*Get Content attribute ===========*/
1264         mmf_error = mm_file_create_content_attrs(&content, content_info->path);
1265         if (mmf_error == MM_ERROR_NONE) {
1266                 /*Common attribute*/
1267                 mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_DURATION, &content_info->media_meta.duration, NULL);
1268                 if (mmf_error != MM_ERROR_NONE) {
1269                         SAFE_FREE(err_attr_name);
1270                         media_svc_debug("fail to get duration attr - err(%x)", mmf_error);
1271                 } else {
1272                         //media_svc_debug("duration : %d", content_info->media_meta.duration);
1273                 }
1274
1275                 /*Sound/Music attribute*/
1276                 if((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) || (media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
1277
1278                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &content_info->media_meta.bitrate, NULL);
1279                         if (mmf_error != MM_ERROR_NONE) {
1280                                 SAFE_FREE(err_attr_name);
1281                                 media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
1282                         } else {
1283                                 //media_svc_debug("bit rate : %d", content_info->media_meta.bitrate);
1284                         }
1285
1286                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &content_info->media_meta.samplerate, NULL);
1287                         if (mmf_error != MM_ERROR_NONE) {
1288                                 SAFE_FREE(err_attr_name);
1289                                 media_svc_debug("fail to get sample rate attr - err(%x)", mmf_error);
1290                         } else {
1291                                 //media_svc_debug("sample rate : %d", content_info->media_meta.samplerate);
1292                         }
1293
1294                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_CHANNELS, &content_info->media_meta.channel, NULL);
1295                         if (mmf_error != MM_ERROR_NONE) {
1296                                 SAFE_FREE(err_attr_name);
1297                                 media_svc_debug("fail to get audio channels attr - err(%x)", mmf_error);
1298                         } else {
1299                                 //media_svc_debug("channel : %d", content_info->media_meta.channel);
1300                         }
1301                 }else if(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)      {       /*Video attribute*/
1302                         int audio_bitrate = 0;
1303                         int video_bitrate = 0;
1304
1305                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &audio_bitrate, NULL);
1306                         if (mmf_error != MM_ERROR_NONE) {
1307                                 SAFE_FREE(err_attr_name);
1308                                 media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
1309                         } else {
1310                                 //media_svc_debug("audio bit rate : %d", audio_bitrate);
1311                         }
1312
1313                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_BITRATE, &video_bitrate, NULL);
1314                         if (mmf_error != MM_ERROR_NONE) {
1315                                 SAFE_FREE(err_attr_name);
1316                                 media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
1317                         } else {
1318                                 //media_svc_debug("video bit rate : %d", video_bitrate);
1319                         }
1320
1321                         content_info->media_meta.bitrate = audio_bitrate + video_bitrate;
1322
1323                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_WIDTH, &content_info->media_meta.width, NULL);
1324                         if (mmf_error != MM_ERROR_NONE) {
1325                                 SAFE_FREE(err_attr_name);
1326                                 media_svc_debug("fail to get video width attr - err(%x)", mmf_error);
1327                         } else {
1328                                 //media_svc_debug("width : %d", content_info->media_meta.width);
1329                         }
1330
1331                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_HEIGHT, &content_info->media_meta.height, NULL);
1332                         if (mmf_error != MM_ERROR_NONE) {
1333                                 SAFE_FREE(err_attr_name);
1334                                 media_svc_debug("fail to get video height attr - err(%x)", mmf_error);
1335                         } else {
1336                                 //media_svc_debug("height : %d", content_info->media_meta.height);
1337                         }
1338
1339                 } else {
1340                         media_svc_error("Not support type");
1341                         return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1342                 }
1343
1344                 mmf_error = mm_file_destroy_content_attrs(content);
1345                 if (mmf_error != MM_ERROR_NONE) {
1346                         media_svc_error("fail to free content attr - err(%x)", mmf_error);
1347                 }
1348         } else {
1349                 media_svc_error("error in mm_file_create_content_attrs [%d]", mmf_error);
1350         }
1351
1352         /*Get Content Tag attribute ===========*/
1353         mmf_error = mm_file_create_tag_attrs(&tag, content_info->path);
1354
1355         if (mmf_error == MM_ERROR_NONE) {
1356                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ALBUM, &p, &size, NULL);
1357                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_ALBUM)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1358                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, p);
1359                         if(ret != MEDIA_INFO_ERROR_NONE)
1360                                 media_svc_error("strcpy error");
1361
1362                         //media_svc_debug("album[%d] : %s", size, content_info->media_meta.album);
1363                 } else {
1364                         SAFE_FREE(err_attr_name);
1365                         //media_svc_debug("album - unknown");
1366                 }
1367
1368                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTIST, &p, &size, NULL);
1369                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_ARTIST)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1370                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, p);
1371                         if(ret != MEDIA_INFO_ERROR_NONE)
1372                                 media_svc_error("strcpy error");
1373                         //media_svc_debug("artist[%d] : %s", size, content_info->media_meta.artist);
1374                 } else {
1375                         SAFE_FREE(err_attr_name);
1376                         //media_svc_debug("artist - unknown");
1377                 }
1378
1379                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_GENRE, &p, &size, NULL);
1380                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_GENRE)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1381                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, p);
1382                         if(ret != MEDIA_INFO_ERROR_NONE)
1383                                 media_svc_error("strcpy error");
1384
1385                         //media_svc_debug("genre : %s", content_info->media_meta.genre);
1386                         /* If genre is Ringtone, it's categorized as sound. But this logic is commented */
1387                         /*
1388                         if ((strcasecmp("Ringtone", p) == 0) | (strcasecmp("Alert tone", p) == 0)) {
1389                                 content_info->media_type = MEDIA_SVC_MEDIA_TYPE_SOUND;
1390                         }
1391                         */
1392                 } else {
1393                         SAFE_FREE(err_attr_name);
1394                         //media_svc_debug("genre - unknown");
1395                 }
1396
1397                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_TITLE, &p, &size, NULL);
1398                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) && (mmf_error == MM_ERROR_NONE) && (size > 0)/* &&   (!isspace(*p))*/) {
1399                         if(!isspace(*p)) {
1400                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, p);
1401                                 if(ret != MEDIA_INFO_ERROR_NONE)
1402                                         media_svc_error("strcpy error");
1403
1404                                 extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
1405                                 //media_svc_debug("extract title from content : %s", content_info->media_meta.title);
1406                                 //media_svc_debug("^^^^^^^^^^^^^^^ path = %s, title = %s, size = %d ^^^^^^^^^^^^^^", content_info->path, content_info->media_meta.title, size);
1407                         }
1408                         else {
1409                                 int idx = 0;
1410
1411                                 for(idx = 0; idx < size; idx++) {
1412                                         if(isspace(*p)) {
1413                                                 media_svc_debug("SPACE [%s]", p);
1414                                                 p++;
1415                                                 continue;
1416                                         } else {
1417                                                 media_svc_debug("Not SPACE [%s]", p);
1418                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, p);
1419                                                 if(ret != MEDIA_INFO_ERROR_NONE)
1420                                                         media_svc_error("strcpy error");
1421                                                 break;
1422                                         }
1423                                 }
1424
1425                                 if(idx == size)
1426                                 {
1427                                         media_svc_debug("Can't extract title. All string is space");
1428                                         title = _media_svc_get_title_from_filepath(content_info->path);
1429                                         if (title) {
1430                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1431                                                 if(ret != MEDIA_INFO_ERROR_NONE)
1432                                                         media_svc_error("strcpy error");
1433                                                 SAFE_FREE(title);
1434                                         } else {
1435                                                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1436                                         }
1437                                 }
1438                         }
1439                 } else {
1440                         SAFE_FREE(err_attr_name);
1441                         title = _media_svc_get_title_from_filepath(content_info->path);
1442                         if (title) {
1443                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1444                                 if(ret != MEDIA_INFO_ERROR_NONE)
1445                                         media_svc_error("strcpy error");
1446                                 SAFE_FREE(title);
1447                         } else {
1448                                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1449                         }
1450                 }
1451
1452                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_DESCRIPTION, &p, &size, NULL);
1453                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_DESC)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1454                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, p);
1455                         if(ret != MEDIA_INFO_ERROR_NONE)
1456                                 media_svc_error("strcpy error");
1457                         //media_svc_debug("desc : %s", content_info->media_meta.description);
1458                 } else {
1459                         SAFE_FREE(err_attr_name);
1460                 }
1461
1462                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RECDATE, &p, &size, NULL);
1463                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_DESC)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1464                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.recorded_date, p);
1465                         if(ret != MEDIA_INFO_ERROR_NONE)
1466                                 media_svc_error("strcpy error");
1467                         //media_svc_debug("Recorded date : %s", content_info->media_meta.recorded_date);
1468                 } else {
1469                         SAFE_FREE(err_attr_name);
1470                 }
1471
1472                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_AUTHOR, &p, &size, NULL);
1473                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_AUTHOR)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1474                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, p);
1475                         if(ret != MEDIA_INFO_ERROR_NONE)
1476                                 media_svc_error("strcpy error");
1477                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
1478                         //media_svc_debug("extract composer from content : %s", content_info->media_meta.composer);
1479                 } else {
1480                         //media_svc_debug("composer - unknown");
1481                         SAFE_FREE(err_attr_name);
1482                 }
1483
1484                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_COPYRIGHT, &p, &size, NULL);
1485                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1486                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, p);
1487                         if(ret != MEDIA_INFO_ERROR_NONE)
1488                                 media_svc_error("strcpy error");
1489                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
1490                         //media_svc_debug("extract copyright from content : %s", content_info->media_meta.copyright);
1491                 } else {
1492                         //media_svc_debug("copyright - unknown");
1493                         SAFE_FREE(err_attr_name);
1494                 }
1495
1496                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_TRACK_NUM, &p, &size, NULL);
1497                 if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
1498                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, p);
1499                         if(ret != MEDIA_INFO_ERROR_NONE)
1500                                 media_svc_error("strcpy error");
1501                 } else {
1502                         SAFE_FREE(err_attr_name);
1503                 }
1504
1505                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_DATE, &p, &size, NULL);
1506                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_YEAR)) && (mmf_error == MM_ERROR_NONE) && (size == 4)) {
1507                         int year = 0;
1508                         if((p != NULL) && (sscanf( p, "%d", &year))) {
1509                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, p);
1510                                 if(ret != MEDIA_INFO_ERROR_NONE)
1511                                         media_svc_error("strcpy error");
1512                         } else {
1513                                 media_svc_debug("Wrong Year Information [%s]", p);
1514                         }
1515                 } else {
1516                         SAFE_FREE(err_attr_name);
1517                 }
1518
1519                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RATING, &p, &size, NULL);
1520                 if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
1521                         content_info->media_meta.rating = atoi(p);
1522                 } else {
1523                         SAFE_FREE(err_attr_name);
1524                         content_info->media_meta.rating = 0;
1525                 }
1526
1527                 /*Initialize album_id to 0. below code will set the album_id*/
1528                 content_info->album_id = album_id;
1529 #if 0
1530                 /* extract thumbnail image */
1531                 if(strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) {
1532                         if(strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) {
1533
1534                                 ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
1535
1536                                 if (ret != MEDIA_INFO_ERROR_NONE) {
1537                                         if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
1538                                                 media_svc_debug("album does not exist. So start to make album art");
1539                                                 extract_thumbnail = TRUE;
1540                                                 append_album = TRUE;
1541                                         } else {
1542                                                 extract_thumbnail = FALSE;
1543                                                 append_album = FALSE;
1544                                         }
1545                                 } else {
1546                                         media_svc_debug("album already exists. don't need to make album art");
1547                                         content_info->album_id = album_id;
1548                                         ret = _media_svc_get_album_art_by_album_id(handle, album_id, &content_info->thumbnail_path);
1549                                         media_svc_retv_del_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret, content_info);
1550                                         extract_thumbnail = FALSE;
1551                                         append_album = FALSE;
1552                                 }
1553                         } else {
1554                                 ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
1555
1556                                 if (ret != MEDIA_INFO_ERROR_NONE) {
1557                                         if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
1558                                                 media_svc_debug("Unknown artist album does not exist.");
1559                                                 extract_thumbnail = TRUE;
1560                                                 append_album = TRUE;
1561                                         } else {
1562                                                 extract_thumbnail = FALSE;
1563                                                 append_album = FALSE;
1564                                         }
1565                                 } else {
1566                                         media_svc_debug("Unknown artist album already exists.");
1567
1568                                         content_info->album_id = album_id;
1569                                         extract_thumbnail = TRUE;
1570                                         append_album = FALSE;
1571                                 }
1572                         }
1573                 } else {
1574                         extract_thumbnail = TRUE;
1575                         append_album = FALSE;
1576                 }
1577 #else
1578                 ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
1579
1580                 if (ret != MEDIA_INFO_ERROR_NONE) {
1581                         if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
1582                                 media_svc_debug("album does not exist. So start to make album art");
1583                                 extract_thumbnail = TRUE;
1584                                 append_album = TRUE;
1585                         } else {
1586                                 extract_thumbnail = FALSE;
1587                                 append_album = FALSE;
1588                         }
1589                 } else {
1590                         content_info->album_id = album_id;
1591                         append_album = FALSE;
1592
1593                         if((!strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) ||
1594                                 (!strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN)))) {
1595
1596                                 media_svc_debug("Unknown album or artist already exists. Extract thumbnail for Unknown.");
1597                                 extract_thumbnail = TRUE;
1598                         } else {
1599
1600                                 media_svc_debug("album already exists. don't need to make album art");
1601                                 ret = _media_svc_get_album_art_by_album_id(handle, album_id, &content_info->thumbnail_path);
1602                                 media_svc_retv_del_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret, content_info);
1603                                 extract_thumbnail = FALSE;
1604                         }
1605                 }
1606 #endif
1607
1608                 if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE)) {
1609                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK, &image, &size, NULL);
1610                         if (mmf_error != MM_ERROR_NONE) {
1611                                 media_svc_error("fail to get tag artwork - err(%x)", mmf_error);
1612                                 SAFE_FREE(err_attr_name);
1613                         } else {
1614                                 //media_svc_debug("artwork size1 [%d]", size);
1615                         }
1616
1617                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_SIZE, &size, NULL);
1618                         if (mmf_error != MM_ERROR_NONE) {
1619                                 media_svc_error("fail to get artwork size - err(%x)", mmf_error);
1620                                 SAFE_FREE(err_attr_name);
1621                         } else {
1622                                 //media_svc_debug("artwork size2 [%d]", size);
1623                         }
1624                         if (image != NULL && size > 0) {
1625                                 bool result = FALSE;
1626                                 int ret = MEDIA_INFO_ERROR_NONE;
1627                                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = "\0";
1628                                 int artwork_mime_size = -1;
1629
1630                                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_MIME, &p, &artwork_mime_size, NULL);
1631                                 if ((mmf_error == MM_ERROR_NONE) && (artwork_mime_size > 0)) {
1632                                         result = _media_svc_get_thumbnail_path(content_info->storage_type, thumb_path, content_info->path, p);
1633                                         if (result == FALSE) {
1634                                                 media_svc_error("Fail to Get Thumbnail Path");
1635                                         }
1636                                 } else {
1637                                         SAFE_FREE(err_attr_name);
1638                                 }
1639
1640                                 if(strlen(thumb_path) > 0)
1641                                 {
1642                                         ret = _media_svc_save_image(image, size, thumb_path);
1643                                         if (ret != MEDIA_INFO_ERROR_NONE) {
1644                                                 media_svc_error("Fail to Save Thumbnail Image");
1645                                         }
1646                                         else {
1647                                                 ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
1648                                                 if(ret != MEDIA_INFO_ERROR_NONE)
1649                                                         media_svc_error("strcpy error");
1650                                         }
1651                                 }
1652                         }
1653                 }
1654
1655                 if(append_album == TRUE) {
1656
1657                         if((strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) &&
1658                                 (strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))))
1659                                 ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, content_info->thumbnail_path, &album_id);
1660                         else
1661                                 ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, NULL, &album_id);
1662
1663                         content_info->album_id = album_id;
1664                 }
1665
1666                 if(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1667                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_LONGITUDE, &gps_value, NULL);
1668                         if (mmf_error == MM_ERROR_NONE) {
1669                                 if (gps_value == 0.0)
1670                                         content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
1671                                 else
1672                                         content_info->media_meta.longitude = gps_value;
1673                         } else {
1674                                 SAFE_FREE(err_attr_name);
1675                         }
1676
1677                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_LATIDUE, &gps_value, NULL);
1678                         if (mmf_error == MM_ERROR_NONE) {
1679                                 if (gps_value == 0.0)
1680                                         content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
1681                                 else
1682                                         content_info->media_meta.latitude = gps_value;
1683                         } else {
1684                                 SAFE_FREE(err_attr_name);
1685                         }
1686
1687                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ALTIDUE, &gps_value, NULL);
1688                         if (mmf_error == MM_ERROR_NONE) {
1689                                 if (gps_value == 0.0)
1690                                         content_info->media_meta.altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
1691                                 else
1692                                         content_info->media_meta.altitude = gps_value;
1693                         } else {
1694                                 SAFE_FREE(err_attr_name);
1695                         }
1696 #if 0
1697                         //if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE))
1698                         {
1699                                 /* Extracting thumbnail */
1700                                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
1701                                 int width = 0;
1702                                 int height = 0;
1703
1704                                 ret = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
1705                                 if (ret < 0) {
1706                                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
1707                                 } else {
1708                                         //media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
1709                                 }
1710
1711                                 ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
1712                                 if(ret != MEDIA_INFO_ERROR_NONE)
1713                                         media_svc_error("strcpy error");
1714
1715                                 if (content_info->media_meta.width <= 0) content_info->media_meta.width = width;
1716                                 if (content_info->media_meta.height <= 0) content_info->media_meta.height = height;
1717                         }
1718 #endif
1719                 }
1720
1721                 mmf_error = mm_file_destroy_tag_attrs(tag);
1722                 if (mmf_error != MM_ERROR_NONE) {
1723                         media_svc_error("fail to free tag attr - err(%x)", mmf_error);
1724                 }
1725         }       else {
1726                 /* in case of file size 0, MMFW Can't parsting tag info but add it to Music DB. */
1727                 char *title = NULL;
1728                 media_svc_error("no tag information");
1729
1730                 title = _media_svc_get_title_from_filepath(content_info->path);
1731                 if (title) {
1732                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1733                         if(ret != MEDIA_INFO_ERROR_NONE)
1734                                 media_svc_error("strcpy error");
1735                         SAFE_FREE(title);
1736                 } else {
1737                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1738                 }
1739
1740                 content_info->album_id = album_id;
1741         }
1742
1743         return MEDIA_INFO_ERROR_NONE;
1744 }
1745
1746 void _media_svc_destroy_content_info(media_svc_content_info_s *content_info)
1747 {
1748         media_svc_retm_if(content_info == NULL, "content info is NULL");
1749
1750         /* Delete media_svc_content_info_s */
1751         SAFE_FREE(content_info->media_uuid);
1752         SAFE_FREE(content_info->path);
1753         SAFE_FREE(content_info->file_name);
1754         SAFE_FREE(content_info->mime_type);
1755         SAFE_FREE(content_info->folder_uuid);
1756         SAFE_FREE(content_info->thumbnail_path);
1757
1758         /* Delete media_svc_content_meta_s */
1759         SAFE_FREE(content_info->media_meta.title);
1760         SAFE_FREE(content_info->media_meta.album);
1761         SAFE_FREE(content_info->media_meta.artist);
1762         SAFE_FREE(content_info->media_meta.genre);
1763         SAFE_FREE(content_info->media_meta.composer);
1764         SAFE_FREE(content_info->media_meta.year);
1765         SAFE_FREE(content_info->media_meta.recorded_date);
1766         SAFE_FREE(content_info->media_meta.copyright);
1767         SAFE_FREE(content_info->media_meta.track_num);
1768         SAFE_FREE(content_info->media_meta.description);
1769         SAFE_FREE(content_info->media_meta.datetaken);
1770
1771         return;
1772 }
1773
1774 int _media_svc_get_store_type_by_path(const char *path, media_svc_storage_type_e *storage_type)
1775 {
1776         if(STRING_VALID(path))
1777         {
1778                 if(strncmp(path, MEDIA_SVC_PATH_PHONE, strlen(MEDIA_SVC_PATH_PHONE)) == 0)
1779                 {
1780                         *storage_type = MEDIA_SVC_STORAGE_INTERNAL;
1781                 }
1782                 else if(strncmp (path, MEDIA_SVC_PATH_MMC, strlen(MEDIA_SVC_PATH_MMC)) == 0)
1783                 {
1784                         *storage_type = MEDIA_SVC_STORAGE_EXTERNAL;
1785                 }
1786         }
1787         else
1788         {
1789                 media_svc_error("INVALID parameter");
1790                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1791         }
1792
1793         return MEDIA_INFO_ERROR_NONE;
1794 }
1795
1796 char *_media_svc_replace_path(char *s, const char *olds, const char *news)
1797 {
1798   char *result, *sr;
1799   size_t i, count = 0;
1800   size_t oldlen = strlen(olds); if (oldlen < 1) return s;
1801   size_t newlen = strlen(news);
1802
1803   if (newlen != oldlen) {
1804     for (i = 0; s[i] != '\0';) {
1805       if (memcmp(&s[i], olds, oldlen) == 0) count++, i += oldlen;
1806       else i++;
1807     }
1808   } else i = strlen(s);
1809
1810
1811   result = (char *) calloc(1, i + 1 + count * (newlen - oldlen));
1812   if (result == NULL) return NULL;
1813
1814   sr = result;
1815   while (*s) {
1816     if (memcmp(s, olds, oldlen) == 0) {
1817       memcpy(sr, news, newlen);
1818       sr += newlen;
1819       s  += oldlen;
1820     } else *sr++ = *s++;
1821   }
1822
1823   *sr = '\0';
1824
1825   return result;
1826 }
1827
1828 int _media_svc_error_convert(int error)
1829 {
1830         media_svc_debug("error : [%d]", error);
1831
1832         if(error == MS_MEDIA_ERR_NONE)                                                  /*Error None*/
1833                 return MEDIA_INFO_ERROR_NONE;
1834         else if(error == MS_MEDIA_ERR_DB_CONNECT_FAIL)                  /*DB Connect Fail*/
1835                 return MEDIA_INFO_ERROR_DATABASE_CONNECT;
1836         else if(error == MS_MEDIA_ERR_DB_DISCONNECT_FAIL)               /*DB Disconnect Fail*/
1837                 return MEDIA_INFO_ERROR_DATABASE_DISCONNECT;
1838         else if(error == MS_MEDIA_ERR_SOCKET_CONN)                              /*Socket Connect Fail*/
1839                 return MEDIA_INFO_ERROR_SOCKET_CONN;
1840         else if(error == MS_MEDIA_ERR_INVALID_PARAMETER || error == MS_MEDIA_ERR_INVALID_PATH)
1841                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1842
1843         return MEDIA_INFO_ERROR_INTERNAL;
1844 }
1845
1846
1847 bool _media_svc_is_drm_file(const char *path)
1848 {
1849         int ret;
1850         drm_bool_type_e is_drm_file = DRM_UNKNOWN;
1851
1852         ret = drm_is_drm_file(path,&is_drm_file);
1853         if(DRM_RETURN_SUCCESS == ret && DRM_TRUE == is_drm_file)
1854                 return TRUE;
1855
1856         return FALSE;
1857 }
1858
1859 int _media_svc_get_mime_in_drm_info(const char *path, char *mime, drm_content_info_s **drm_contentInfo)
1860 {
1861         int ret = MEDIA_INFO_ERROR_NONE;
1862         drm_file_type_e file_type = DRM_TYPE_UNDEFINED;
1863
1864         if (path == NULL || mime == NULL)
1865                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1866
1867         ret = drm_get_file_type(path, &file_type);
1868         if (ret != DRM_RETURN_SUCCESS) {
1869                 media_svc_error("drm_get_file_type() failed : %d", ret);
1870                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1871         } else {
1872                 if (file_type == DRM_TYPE_OMA_V1
1873                 || file_type == DRM_TYPE_OMA_V2
1874                 || file_type == DRM_TYPE_OMA_PD) {
1875                         *drm_contentInfo = malloc(sizeof(drm_content_info_s));
1876                         memset(*drm_contentInfo,0x0,sizeof(drm_content_info_s));
1877                         ret = drm_get_content_info(path, *drm_contentInfo);
1878                         if (ret != DRM_RETURN_SUCCESS) {
1879                                 media_svc_error("drm_svc_get_content_info() fails :%d ", ret);
1880                                 free(*drm_contentInfo);
1881                                 *drm_contentInfo = NULL;
1882                                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1883                         }
1884
1885                         if (STRING_VALID((*drm_contentInfo)->mime_type)) {
1886                                 strncpy(mime,(*drm_contentInfo)->mime_type, MEDIA_SVC_METADATA_LEN_MAX);
1887                                 media_svc_debug("DRM contentType : %s",(*drm_contentInfo)->mime_type);
1888                         } else {
1889                                 free(*drm_contentInfo);
1890                                 *drm_contentInfo = NULL;
1891                                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1892                         }
1893                 } else {
1894                         media_svc_error("THIS IS DRM BUT YOU SHOULD USE API OF AUL LIBRARY");
1895                         *drm_contentInfo = NULL;
1896                         return MEDIA_INFO_ERROR_INVALID_MEDIA;
1897                 }
1898         }
1899
1900         return MEDIA_INFO_ERROR_NONE;
1901 }
1902
1903 int _media_svc_get_content_type_from_mime(const char * path, const char * mimetype, int * category)
1904 {
1905         int i = 0;
1906         int err = 0;
1907
1908         *category = MEDIA_SVC_CATEGORY_UNKNOWN;
1909
1910         //media_svc_debug("mime type : %s", mimetype);
1911
1912         /*categorize from mimetype */
1913         for (i = 0; i < CONTENT_TYPE_NUM; i++) {
1914                 if (strstr(mimetype, content_category[i].content_type) != NULL) {
1915                         *category = (*category | content_category[i].category_by_mime);
1916                         break;
1917                 }
1918         }
1919
1920         /*in application type, exitst sound file ex) x-smafs */
1921         if (*category & MEDIA_SVC_CATEGORY_ETC) {
1922                 int prefix_len = strlen(content_category[0].content_type);
1923
1924                 for (i = 0; i < SOUND_MIME_NUM; i++) {
1925                         if (strstr(mimetype + prefix_len, sound_mime_table[i]) != NULL) {
1926                                 *category ^= MEDIA_SVC_CATEGORY_ETC;
1927                                 *category |= MEDIA_SVC_CATEGORY_SOUND;
1928                                 break;
1929                         }
1930                 }
1931         }
1932
1933         /*check music file in soun files. */
1934         if (*category & MEDIA_SVC_CATEGORY_SOUND) {
1935                 int prefix_len = strlen(content_category[0].content_type) + 1;
1936
1937                 //MS_DBG("mime_type : %s", mimetype + prefix_len);
1938
1939                 for (i = 0; i < MUSIC_MIME_NUM; i++) {
1940                         if (strcmp(mimetype + prefix_len, music_mime_table[i]) == 0) {
1941                                 *category ^= MEDIA_SVC_CATEGORY_SOUND;
1942                                 *category |= MEDIA_SVC_CATEGORY_MUSIC;
1943                                 break;
1944                         }
1945                 }
1946         } else if (*category & MEDIA_SVC_CATEGORY_VIDEO) {
1947                 /*some video files don't have video stream. in this case it is categorize as music. */
1948                 char *ext;
1949                 /*"3gp" and "mp4" must check video stream and then categorize in directly. */
1950                 ext = strrchr(path, '.');
1951                 if (ext != NULL) {
1952                         if ((strncasecmp(ext, _3GP_FILE, 4) == 0) || (strncasecmp(ext, _MP4_FILE, 5) == 0)) {
1953                                 int audio = 0;
1954                                 int video = 0;
1955
1956                                 err = mm_file_get_stream_info(path, &audio, &video);
1957                                 if (err == 0) {
1958                                         if (audio > 0 && video == 0) {
1959                                                 *category ^= MEDIA_SVC_CATEGORY_VIDEO;
1960                                                 *category |= MEDIA_SVC_CATEGORY_MUSIC;
1961                                         }
1962                                 }
1963                         }
1964                 }
1965         }
1966
1967         //media_svc_debug("category_from_ext : %d", *category);
1968
1969         return err;
1970 }
1971
1972 /*
1973 drm_contentifo is not NULL, if the file is OMA DRM.
1974 If the file is not OMA DRM, drm_contentinfo must be NULL.
1975 */
1976 int _media_svc_get_mime_type(const char *path, char *mimetype, drm_bool_type_e *is_drm, drm_content_info_s **drm_contentInfo)
1977 {
1978         int ret = MEDIA_INFO_ERROR_NONE;
1979
1980         if (path == NULL)
1981                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1982
1983         /* In case of drm file. */
1984         if (_media_svc_is_drm_file(path)) {
1985                 *is_drm = DRM_TRUE;
1986                 ret =  _media_svc_get_mime_in_drm_info(path, mimetype, drm_contentInfo);
1987                 if (ret == MEDIA_INFO_ERROR_NONE) {
1988                         return ret;
1989                 }
1990         }
1991
1992         /*in case of normal files or failure to get mime in drm */
1993         if (aul_get_mime_from_file(path, mimetype, 255) < 0) {
1994                 media_svc_error("aul_get_mime_from_file fail");
1995                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1996         }
1997
1998         return MEDIA_INFO_ERROR_NONE;
1999 }
2000
2001 int _media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
2002 {
2003         int ret = MEDIA_INFO_ERROR_NONE;
2004         int category = 0;
2005
2006         media_svc_media_type_e type;
2007
2008         ret = _media_svc_get_content_type_from_mime(path, mime_type, &category);
2009         if (ret < 0) {
2010                 media_svc_error("_media_svc_get_content_type_from_mime failed : %d", ret);
2011         }
2012
2013         if (category & MEDIA_SVC_CATEGORY_SOUND)                type = MEDIA_SVC_MEDIA_TYPE_SOUND;
2014         else if (category & MEDIA_SVC_CATEGORY_MUSIC)   type = MEDIA_SVC_MEDIA_TYPE_MUSIC;
2015         else if (category & MEDIA_SVC_CATEGORY_IMAGE)   type = MEDIA_SVC_MEDIA_TYPE_IMAGE;
2016         else if (category & MEDIA_SVC_CATEGORY_VIDEO)   type = MEDIA_SVC_MEDIA_TYPE_VIDEO;
2017         else    type = MEDIA_SVC_MEDIA_TYPE_OTHER;
2018
2019         *media_type = type;
2020
2021         return ret;
2022 }
2023