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 filename to title for all media */
 573         char *title = NULL;
 574         title = _media_svc_get_title_from_filepath(content_info->path);
 575         if (title) {
 576                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
 577                 if(ret != MEDIA_INFO_ERROR_NONE)
 578                         media_svc_error("strcpy error");
 579                 SAFE_FREE(title);
 580         } else {
 581                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
 582                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, MEDIA_SVC_TAG_UNKNOWN);
 583                 media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 584         }
 585
 586         /* Set default value before extracting meta information */
 587         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
 588         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 589
 590         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, MEDIA_SVC_TAG_UNKNOWN);
 591         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 592
 593         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, MEDIA_SVC_TAG_UNKNOWN);
 594         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 595
 596         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN);
 597         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 598
 599         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN);
 600         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 601
 602         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, MEDIA_SVC_TAG_UNKNOWN);
 603         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 604
 605         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, MEDIA_SVC_TAG_UNKNOWN);
 606         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 607
 608         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, MEDIA_SVC_TAG_UNKNOWN);
 609         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 610
 611         /* refresh is TRUE when file modified. so only modified_time and size are changed*/
 612         if(refresh) {
 613                 media_svc_debug("refresh");
 614                 return MEDIA_INFO_ERROR_NONE;
 615         }
 616
 617         content_info->storage_type = storage_type;
 618         time(&content_info->added_time);
 619
 620         media_uuid = _media_info_generate_uuid();
 621         media_svc_retvm_if(media_uuid == NULL, MEDIA_INFO_ERROR_INTERNAL, "Invalid UUID");
 622
 623         ret = __media_svc_malloc_and_strncpy(&content_info->media_uuid, media_uuid);
 624         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 625
 626         file_name = g_path_get_basename(path);
 627         ret = __media_svc_malloc_and_strncpy(&content_info->file_name, file_name);
 628         SAFE_FREE(file_name);
 629         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 630
 631         /* if the file is DRM file, drm_type value is DRM_TRUE(1).
 632         if drm_contentinfo is not NULL, the file is OMA DRM.*/
 633         ret = _media_svc_get_mime_type(path, mime_type, &drm_type, drm_contentInfo);
 634         if (ret < 0) {
 635                 media_svc_error("media_svc_get_mime_type failed : %d (%s)", ret, path);
 636                 return MEDIA_INFO_ERROR_INVALID_PATH;
 637         }
 638
 639         media_svc_error("mime [%s]", mime_type);
 640         content_info->is_drm = drm_type;
 641
 642         ret = _media_svc_get_media_type(path, mime_type, media_type);
 643         media_svc_retv_if(ret != MEDIA_INFO_ERROR_NONE, ret);
 644         if ((*media_type < MEDIA_SVC_MEDIA_TYPE_IMAGE) || (*media_type > MEDIA_SVC_MEDIA_TYPE_OTHER)) {
 645                 media_svc_error("invalid media_type condition[%d]", *media_type);
 646                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 647         }
 648
 649         ret = __media_svc_malloc_and_strncpy(&content_info->mime_type, mime_type);
 650         media_svc_retv_del_if(ret != MEDIA_INFO_ERROR_NONE, ret, content_info);
 651
 652         media_svc_debug("storage[%d], path[%s], media_type[%d]", storage_type, path, *media_type);
 653
 654         content_info->media_type = *media_type;
 655
 656         content_info->played_count = 0;
 657         content_info->last_played_time= 0;
 658         content_info->last_played_position= 0;
 659         content_info->favourate= 0;
 660         content_info->media_meta.rating = 0;
 661
 662         return MEDIA_INFO_ERROR_NONE;
 663 }
 664
 665 int _media_svc_extract_image_metadata(media_svc_content_info_s *content_info, media_svc_media_type_e media_type)
 666 {
 667         if (content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE) {
 668                 media_svc_error("content_info == NULL || media_type != MEDIA_SVC_MEDIA_TYPE_IMAGE");
 669                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 670         }
 671
 672         char buf[MEDIA_SVC_METADATA_LEN_MAX + 1] = { '\0' };
 673         char description_buf[MEDIA_SVC_METADATA_DESCRIPTION_MAX + 1] = { '\0' };
 674         memset(buf, 0x00, sizeof(buf));
 675         memset(description_buf, 0x00, sizeof(description_buf));
 676
 677         int ret = MEDIA_INFO_ERROR_NONE;
 678         double value = 0.0;
 679         int orient_value = 0;
 680         int exif_width = 0;
 681         int exif_height = 0;
 682         ExifData *ed = NULL;
 683
 684         char *path = content_info->path;
 685         if (path == NULL) {
 686                 media_svc_error("path is NULL");
 687                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
 688         }
 689
 690         /* Load an ExifData object from an EXIF file */
 691         ed = exif_data_new_from_file(path);
 692
 693         if (!ed) {
 694                 media_svc_debug("There is no exif data in [ %s ]", path);
 695         }
 696
 697         if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LATITUDE_REF) == MEDIA_INFO_ERROR_NONE) {
 698                 if (strlen(buf) != 0) {
 699                         if (__media_svc_get_exif_info(ed, NULL, NULL, &value, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE) == MEDIA_INFO_ERROR_NONE) {
 700
 701                                 if (strcmp(buf, "S") == 0) {
 702                                         value = -1 * value;
 703                                 }
 704
 705                                 content_info->media_meta.latitude = value;
 706                         } else {
 707                                 content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 708                         }
 709                 } else {
 710                         content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 711                 }
 712         } else {
 713                 content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 714         }
 715
 716         memset(buf, 0x00, sizeof(buf));
 717
 718         if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_GPS_LONGITUDE_REF) == MEDIA_INFO_ERROR_NONE) {
 719                 if (strlen(buf) != 0) {
 720                         if (__media_svc_get_exif_info(ed, NULL, NULL, &value, EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE) == MEDIA_INFO_ERROR_NONE) {
 721                                 if (strcmp(buf, "W") == 0) {
 722                                         value = -1 * value;
 723                                 }
 724                                 content_info->media_meta.longitude = value;
 725                         } else {
 726                                 content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 727                         }
 728                 } else {
 729                         content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 730                 }
 731         } else {
 732                 content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
 733         }
 734
 735         memset(buf, 0x00, sizeof(buf));
 736
 737         if (__media_svc_get_exif_info(ed, description_buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION) == MEDIA_INFO_ERROR_NONE) {
 738                 if (strlen(description_buf) == 0) {
 739                         //media_svc_debug("Use 'No description'");
 740                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
 741                         if(ret != MEDIA_INFO_ERROR_NONE)
 742                                 media_svc_error("strcpy error");
 743                 } else {
 744                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, description_buf);
 745                         if(ret != MEDIA_INFO_ERROR_NONE)
 746                                 media_svc_error("strcpy error");
 747                 }
 748         } else {
 749                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, MEDIA_SVC_TAG_UNKNOWN);
 750                 if(ret != MEDIA_INFO_ERROR_NONE)
 751                         media_svc_error("strcpy error");
 752         }
 753
 754         memset(buf, 0x00, sizeof(buf));
 755
 756         if (__media_svc_get_exif_info(ed, buf, NULL, NULL, EXIF_IFD_0, EXIF_TAG_DATE_TIME) == MEDIA_INFO_ERROR_NONE) {
 757                 if (strlen(buf) == 0) {
 758                         //media_svc_debug("time  is NULL");
 759                 } else {
 760                         //media_svc_debug("time  is %s", buf);
 761                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.datetaken, buf);
 762                         if(ret != MEDIA_INFO_ERROR_NONE) {
 763                                 media_svc_error("strcpy error");
 764                         } else {
 765                                 /* This is same as recorded_date */
 766                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.recorded_date, buf);
 767                                 if(ret != MEDIA_INFO_ERROR_NONE)
 768                                         media_svc_error("strcpy error");
 769                         }
 770                 }
 771         }
 772
 773         /* Get orientation value from exif. */
 774         if (__media_svc_get_exif_info(ed, NULL, &orient_value, NULL, EXIF_IFD_0, EXIF_TAG_ORIENTATION) == MEDIA_INFO_ERROR_NONE) {
 775                 if (orient_value >= NOT_AVAILABLE && orient_value <= ROT_270) {
 776                         content_info->media_meta.orientation = orient_value;
 777                 } else {
 778                         content_info->media_meta.orientation = 0;
 779                 }
 780         } else {
 781                 content_info->media_meta.orientation = 0;
 782         }
 783
 784         /* Get width value from exif. */
 785         if (__media_svc_get_exif_info(ed, NULL, &exif_width, NULL, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION) == MEDIA_INFO_ERROR_NONE) {
 786                 if (exif_width > 0) {
 787                         content_info->media_meta.width = exif_width;
 788                 } else {
 789                         content_info->media_meta.width = 0;
 790                 }
 791         } else {
 792                 content_info->media_meta.width = 0;
 793         }
 794
 795         /* Get height value from exif. */
 796         if (__media_svc_get_exif_info(ed, NULL, &exif_height, NULL, EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION) == MEDIA_INFO_ERROR_NONE) {
 797                 if (exif_height > 0) {
 798                         content_info->media_meta.height = exif_height;
 799                 } else {
 800                         content_info->media_meta.height = 0;
 801                 }
 802         } else {
 803                 content_info->media_meta.height = 0;
 804         }
 805
 806         if (ed != NULL) exif_data_unref(ed);
 807
 808         /* Set filename to title for image media */
 809         char *title = NULL;
 810         title = _media_svc_get_title_from_filepath(content_info->path);
 811         if (title) {
 812                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
 813                 if(ret != MEDIA_INFO_ERROR_NONE)
 814                         media_svc_error("strcpy error");
 815                 SAFE_FREE(title);
 816         } else {
 817                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
 818         }
 819
 820 #if 0
 821         /* Extracting thumbnail */
 822         char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
 823         int width = 0;
 824         int height = 0;
 825
 826         ret = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
 827         if (ret < 0) {
 828                 media_svc_error("thumbnail_request_from_db failed: %d", ret);
 829         } else {
 830                 //media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
 831         }
 832
 833         content_info->media_meta.width = width;
 834         content_info->media_meta.height = height;
 835
 836         if (STRING_VALID(thumb_path))
 837                 ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
 838         else
 839                 content_info->thumbnail_path = NULL;
 840
 841         if(ret != MEDIA_INFO_ERROR_NONE)
 842                 media_svc_error("strcpy error");
 843 #endif
 844         return MEDIA_INFO_ERROR_NONE;
 845 }
 846
 847 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)
 848 {
 849         MMHandleType content = 0;
 850         MMHandleType tag = 0;
 851         char *p = NULL;
 852         void *image = NULL;
 853         int size = -1;
 854         int extracted_field = MEDIA_SVC_EXTRACTED_FIELD_NONE;
 855         int mmf_error = MM_ERROR_NONE;
 856         bool thumb_extracted_from_drm = FALSE;
 857         char *err_attr_name = NULL;
 858         char *title = NULL;
 859         bool extract_thumbnail = FALSE;
 860         bool append_album = FALSE;
 861         int album_id = 0;
 862         double gps_value = 0.0;
 863         int ret = MEDIA_INFO_ERROR_NONE;
 864         char *path = content_info->path;
 865
 866 #ifdef __SUPPORT_DRM
 867         /*To do - code for DRM content*/
 868         if (content_info->is_drm) {
 869                 drm_file_type_e drm_file_type;
 870
 871                 ret = drm_get_file_type(path, &drm_file_type);
 872                 if (ret < 0) {
 873                         media_svc_error("drm_get_file_type falied : %d", ret);
 874                         drm_file_type = DRM_TYPE_UNDEFINED;
 875                 }
 876
 877                 /* if drm_contentinfo is not NULL, the file is OMA DRM.*/
 878                 if (drm_contentInfo != NULL) {
 879                         if (drm_file_type == DRM_TYPE_OMA_V1) {
 880                                 if (strlen(drm_contentInfo->title) > 0) {
 881                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, drm_contentInfo->title);
 882                                         if(ret != MEDIA_INFO_ERROR_NONE)
 883                                                 media_svc_error("strcpy error");
 884                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
 885                                 }
 886
 887                                 if (strlen(drm_contentInfo->description) > 0) {
 888                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, drm_contentInfo->description);
 889                                         if(ret != MEDIA_INFO_ERROR_NONE)
 890                                                 media_svc_error("strcpy error");
 891                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
 892                                 }
 893                         } else if (drm_file_type == DRM_TYPE_OMA_V2) {
 894                                 if (strlen(drm_contentInfo->title) > 0) {
 895                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, drm_contentInfo->title);
 896                                         if(ret != MEDIA_INFO_ERROR_NONE)
 897                                                 media_svc_error("strcpy error");
 898                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
 899                                 }
 900
 901                                 if (strlen(drm_contentInfo->description) > 0) {
 902                                         ret =  __media_svc_malloc_and_strncpy(&content_info->media_meta.description, drm_contentInfo->description);
 903                                         if(ret != MEDIA_INFO_ERROR_NONE)
 904                                                 media_svc_error("strcpy error");
 905                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_DESC;
 906                                 }
 907
 908                                 if (strlen(drm_contentInfo->copyright) > 0) {
 909                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, drm_contentInfo->copyright);
 910                                         if(ret != MEDIA_INFO_ERROR_NONE)
 911                                                 media_svc_error("strcpy error");
 912                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT;
 913                                 }
 914
 915                                 if (strlen(drm_contentInfo->author) > 0) {
 916                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, drm_contentInfo->author);
 917                                         if(ret != MEDIA_INFO_ERROR_NONE)
 918                                                 media_svc_error("strcpy error");
 919                                          ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, drm_contentInfo->author);
 920                                         if(ret != MEDIA_INFO_ERROR_NONE)
 921                                                 media_svc_error("strcpy error");
 922
 923                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
 924                                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_ARTIST;
 925                                 }
 926                         }
 927
 928                         if (!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) {
 929                                 title = _media_svc_get_title_from_filepath(path);
 930                                 if (title) {
 931                                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
 932                                         SAFE_FREE(title);
 933                                         if(ret != MEDIA_INFO_ERROR_NONE)
 934                                                 media_svc_error("strcpy error");
 935                                 } else {
 936                                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
 937                                 }
 938                         }
 939
 940                         return MEDIA_INFO_ERROR_NONE;
 941                 } else {
 942                         media_svc_debug("Some Not OMA Content's metadata is not incrypted so fileinfo can extracted metadata");
 943                 }
 944         }
 945 #endif
 946
 947         /*Get Content attribute ===========*/
 948         mmf_error = mm_file_create_content_attrs(&content, content_info->path);
 949
 950         if (mmf_error == MM_ERROR_NONE) {
 951                 /*Common attribute*/
 952                 mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_DURATION, &content_info->media_meta.duration, NULL);
 953                 if (mmf_error != MM_ERROR_NONE) {
 954                         SAFE_FREE(err_attr_name);
 955                         media_svc_debug("fail to get duration attr - err(%x)", mmf_error);
 956                 } else {
 957                         //media_svc_debug("duration : %d", content_info->media_meta.duration);
 958                 }
 959
 960                 /*Sound/Music attribute*/
 961                 if((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) || (media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
 962
 963                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &content_info->media_meta.bitrate, NULL);
 964                         if (mmf_error != MM_ERROR_NONE) {
 965                                 SAFE_FREE(err_attr_name);
 966                                 media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
 967                         } else {
 968                                 //media_svc_debug("bit rate : %d", content_info->media_meta.bitrate);
 969                         }
 970
 971                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &content_info->media_meta.samplerate, NULL);
 972                         if (mmf_error != MM_ERROR_NONE) {
 973                                 SAFE_FREE(err_attr_name);
 974                                 media_svc_debug("fail to get sample rate attr - err(%x)", mmf_error);
 975                         } else {
 976                                 //media_svc_debug("sample rate : %d", content_info->media_meta.samplerate);
 977                         }
 978
 979                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_CHANNELS, &content_info->media_meta.channel, NULL);
 980                         if (mmf_error != MM_ERROR_NONE) {
 981                                 SAFE_FREE(err_attr_name);
 982                                 media_svc_debug("fail to get audio channels attr - err(%x)", mmf_error);
 983                         } else {
 984                                 //media_svc_debug("channel : %d", content_info->media_meta.channel);
 985                         }
 986                 }else if(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO)      {       /*Video attribute*/
 987                         int audio_bitrate = 0;
 988                         int video_bitrate = 0;
 989
 990                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &audio_bitrate, NULL);
 991                         if (mmf_error != MM_ERROR_NONE) {
 992                                 SAFE_FREE(err_attr_name);
 993                                 media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
 994                         } else {
 995                                 //media_svc_debug("audio bit rate : %d", audio_bitrate);
 996                         }
 997
 998                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_BITRATE, &video_bitrate, NULL);
 999                         if (mmf_error != MM_ERROR_NONE) {
1000                                 SAFE_FREE(err_attr_name);
1001                                 media_svc_debug("fail to get audio bitrate attr - err(%x)", mmf_error);
1002                         } else {
1003                                 //media_svc_debug("video bit rate : %d", video_bitrate);
1004                         }
1005
1006                         content_info->media_meta.bitrate = audio_bitrate + video_bitrate;
1007
1008                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_WIDTH, &content_info->media_meta.width, NULL);
1009                         if (mmf_error != MM_ERROR_NONE) {
1010                                 SAFE_FREE(err_attr_name);
1011                                 media_svc_debug("fail to get video width attr - err(%x)", mmf_error);
1012                         } else {
1013                                 //media_svc_debug("width : %d", content_info->media_meta.width);
1014                         }
1015
1016                         mmf_error = mm_file_get_attrs(content, &err_attr_name, MM_FILE_CONTENT_VIDEO_HEIGHT, &content_info->media_meta.height, NULL);
1017                         if (mmf_error != MM_ERROR_NONE) {
1018                                 SAFE_FREE(err_attr_name);
1019                                 media_svc_debug("fail to get video height attr - err(%x)", mmf_error);
1020                         } else {
1021                                 //media_svc_debug("height : %d", content_info->media_meta.height);
1022                         }
1023
1024                 } else {
1025                         media_svc_error("Not support type");
1026                         return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1027                 }
1028
1029                 mmf_error = mm_file_destroy_content_attrs(content);
1030                 if (mmf_error != MM_ERROR_NONE) {
1031                         media_svc_error("fail to free content attr - err(%x)", mmf_error);
1032                 }
1033         } else {
1034                 media_svc_error("error in mm_file_create_content_attrs [%d]", mmf_error);
1035         }
1036
1037         /*Get Content Tag attribute ===========*/
1038         mmf_error = mm_file_create_tag_attrs(&tag, content_info->path);
1039
1040         if (mmf_error == MM_ERROR_NONE) {
1041                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ALBUM, &p, &size, NULL);
1042                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_ALBUM)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1043                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.album, p);
1044                         if(ret != MEDIA_INFO_ERROR_NONE)
1045                                 media_svc_error("strcpy error");
1046
1047                         //media_svc_debug("album[%d] : %s", size, content_info->media_meta.album);
1048                 } else {
1049                         SAFE_FREE(err_attr_name);
1050                         //media_svc_debug("album - unknown");
1051                 }
1052
1053                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTIST, &p, &size, NULL);
1054                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_ARTIST)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1055                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.artist, p);
1056                         if(ret != MEDIA_INFO_ERROR_NONE)
1057                                 media_svc_error("strcpy error");
1058                         //media_svc_debug("artist[%d] : %s", size, content_info->media_meta.artist);
1059                 } else {
1060                         SAFE_FREE(err_attr_name);
1061                         //media_svc_debug("artist - unknown");
1062                 }
1063
1064                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_GENRE, &p, &size, NULL);
1065                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_GENRE)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1066                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.genre, p);
1067                         if(ret != MEDIA_INFO_ERROR_NONE)
1068                                 media_svc_error("strcpy error");
1069
1070                         //media_svc_debug("genre : %s", content_info->media_meta.genre);
1071                         /* If genre is Ringtone, it's categorized as sound. But this logic is commented */
1072                         /*
1073                         if ((strcasecmp("Ringtone", p) == 0) | (strcasecmp("Alert tone", p) == 0)) {
1074                                 content_info->media_type = MEDIA_SVC_MEDIA_TYPE_SOUND;
1075                         }
1076                         */
1077                 } else {
1078                         SAFE_FREE(err_attr_name);
1079                         //media_svc_debug("genre - unknown");
1080                 }
1081
1082                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_TITLE, &p, &size, NULL);
1083                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_TITLE)) && (mmf_error == MM_ERROR_NONE) && (size > 0)/* &&   (!isspace(*p))*/) {
1084                         if(!isspace(*p)) {
1085                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, p);
1086                                 if(ret != MEDIA_INFO_ERROR_NONE)
1087                                         media_svc_error("strcpy error");
1088
1089                                 extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_TITLE;
1090                                 //media_svc_debug("extract title from content : %s", content_info->media_meta.title);
1091                                 //media_svc_debug("^^^^^^^^^^^^^^^ path = %s, title = %s, size = %d ^^^^^^^^^^^^^^", content_info->path, content_info->media_meta.title, size);
1092                         }
1093                         else {
1094                                 int idx = 0;
1095
1096                                 for(idx = 0; idx < size; idx++) {
1097                                         if(isspace(*p)) {
1098                                                 media_svc_debug("SPACE [%s]", p);
1099                                                 p++;
1100                                                 continue;
1101                                         } else {
1102                                                 media_svc_debug("Not SPACE [%s]", p);
1103                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, p);
1104                                                 if(ret != MEDIA_INFO_ERROR_NONE)
1105                                                         media_svc_error("strcpy error");
1106                                                 break;
1107                                         }
1108                                 }
1109
1110                                 if(idx == size)
1111                                 {
1112                                         media_svc_debug("Can't extract title. All string is space");
1113                                         title = _media_svc_get_title_from_filepath(content_info->path);
1114                                         if (title) {
1115                                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1116                                                 if(ret != MEDIA_INFO_ERROR_NONE)
1117                                                         media_svc_error("strcpy error");
1118                                                 SAFE_FREE(title);
1119                                         } else {
1120                                                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1121                                         }
1122                                 }
1123                         }
1124                 } else {
1125                         SAFE_FREE(err_attr_name);
1126                         title = _media_svc_get_title_from_filepath(content_info->path);
1127                         if (title) {
1128                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1129                                 if(ret != MEDIA_INFO_ERROR_NONE)
1130                                         media_svc_error("strcpy error");
1131                                 SAFE_FREE(title);
1132                         } else {
1133                                 media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1134                         }
1135                 }
1136
1137                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_DESCRIPTION, &p, &size, NULL);
1138                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_DESC)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1139                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.description, p);
1140                         if(ret != MEDIA_INFO_ERROR_NONE)
1141                                 media_svc_error("strcpy error");
1142                         //media_svc_debug("desc : %s", content_info->media_meta.description);
1143                 } else {
1144                         SAFE_FREE(err_attr_name);
1145                 }
1146
1147                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RECDATE, &p, &size, NULL);
1148                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_DESC)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1149                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.recorded_date, p);
1150                         if(ret != MEDIA_INFO_ERROR_NONE) {
1151                                 media_svc_error("strcpy error");
1152                         } else {
1153                                 /* This is same as datetaken */
1154                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.datetaken, p);
1155                                 if(ret != MEDIA_INFO_ERROR_NONE)
1156                                         media_svc_error("strcpy error");
1157                         }
1158                         //media_svc_debug("Recorded date : %s", content_info->media_meta.recorded_date);
1159                 } else {
1160                         SAFE_FREE(err_attr_name);
1161                 }
1162
1163                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_AUTHOR, &p, &size, NULL);
1164                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_AUTHOR)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1165                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.composer, p);
1166                         if(ret != MEDIA_INFO_ERROR_NONE)
1167                                 media_svc_error("strcpy error");
1168                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
1169                         //media_svc_debug("extract composer from content : %s", content_info->media_meta.composer);
1170                 } else {
1171                         //media_svc_debug("composer - unknown");
1172                         SAFE_FREE(err_attr_name);
1173                 }
1174
1175                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_COPYRIGHT, &p, &size, NULL);
1176                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_COPYRIGHT)) && (mmf_error == MM_ERROR_NONE) && (size > 0)) {
1177                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.copyright, p);
1178                         if(ret != MEDIA_INFO_ERROR_NONE)
1179                                 media_svc_error("strcpy error");
1180                         extracted_field |= MEDIA_SVC_EXTRACTED_FIELD_AUTHOR;
1181                         //media_svc_debug("extract copyright from content : %s", content_info->media_meta.copyright);
1182                 } else {
1183                         //media_svc_debug("copyright - unknown");
1184                         SAFE_FREE(err_attr_name);
1185                 }
1186
1187                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_TRACK_NUM, &p, &size, NULL);
1188                 if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
1189                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.track_num, p);
1190                         if(ret != MEDIA_INFO_ERROR_NONE)
1191                                 media_svc_error("strcpy error");
1192                 } else {
1193                         SAFE_FREE(err_attr_name);
1194                 }
1195
1196                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_DATE, &p, &size, NULL);
1197                 if ((!(extracted_field & MEDIA_SVC_EXTRACTED_FIELD_YEAR)) && (mmf_error == MM_ERROR_NONE) && (size == 4)) {
1198                         int year = 0;
1199                         if((p != NULL) && (sscanf( p, "%d", &year))) {
1200                                 ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.year, p);
1201                                 if(ret != MEDIA_INFO_ERROR_NONE)
1202                                         media_svc_error("strcpy error");
1203                         } else {
1204                                 media_svc_debug("Wrong Year Information [%s]", p);
1205                         }
1206                 } else {
1207                         SAFE_FREE(err_attr_name);
1208                 }
1209
1210                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_RATING, &p, &size, NULL);
1211                 if ((mmf_error == MM_ERROR_NONE) && (size > 0)) {
1212                         content_info->media_meta.rating = atoi(p);
1213                 } else {
1214                         SAFE_FREE(err_attr_name);
1215                         content_info->media_meta.rating = 0;
1216                 }
1217
1218                 if((media_type == MEDIA_SVC_MEDIA_TYPE_SOUND) || (media_type == MEDIA_SVC_MEDIA_TYPE_MUSIC)) {
1219                         /*Initialize album_id to 0. below code will set the album_id*/
1220                         content_info->album_id = album_id;
1221                         ret = _media_svc_get_album_id(handle, content_info->media_meta.album, content_info->media_meta.artist, &album_id);
1222
1223                         if (ret != MEDIA_INFO_ERROR_NONE) {
1224                                 if (ret == MEDIA_INFO_ERROR_DATABASE_NO_RECORD) {
1225                                         media_svc_debug("album does not exist. So start to make album art");
1226                                         extract_thumbnail = TRUE;
1227                                         append_album = TRUE;
1228                                 } else {
1229                                         extract_thumbnail = FALSE;
1230                                         append_album = FALSE;
1231                                 }
1232                         } else {
1233                                 content_info->album_id = album_id;
1234                                 append_album = FALSE;
1235
1236                                 if((!strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) ||
1237                                         (!strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN)))) {
1238
1239                                         media_svc_debug("Unknown album or artist already exists. Extract thumbnail for Unknown.");
1240                                         extract_thumbnail = TRUE;
1241                                 } else {
1242
1243                                         media_svc_debug("album already exists. don't need to make album art");
1244                                         ret = _media_svc_get_album_art_by_album_id(handle, album_id, &content_info->thumbnail_path);
1245                                         media_svc_retv_del_if((ret != MEDIA_INFO_ERROR_NONE) && (ret != MEDIA_INFO_ERROR_DATABASE_NO_RECORD), ret, content_info);
1246                                         extract_thumbnail = FALSE;
1247                                 }
1248                         }
1249
1250                         if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE)) {
1251                                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK, &image, &size, NULL);
1252                                 if (mmf_error != MM_ERROR_NONE) {
1253                                         media_svc_error("fail to get tag artwork - err(%x)", mmf_error);
1254                                         SAFE_FREE(err_attr_name);
1255                                 } else {
1256                                         //media_svc_debug("artwork size1 [%d]", size);
1257                                 }
1258
1259                                 mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_SIZE, &size, NULL);
1260                                 if (mmf_error != MM_ERROR_NONE) {
1261                                         media_svc_error("fail to get artwork size - err(%x)", mmf_error);
1262                                         SAFE_FREE(err_attr_name);
1263                                 } else {
1264                                         //media_svc_debug("artwork size2 [%d]", size);
1265                                 }
1266                                 if (image != NULL && size > 0) {
1267                                         bool result = FALSE;
1268                                         int ret = MEDIA_INFO_ERROR_NONE;
1269                                         char thumb_path[MEDIA_SVC_PATHNAME_SIZE] = "\0";
1270                                         int artwork_mime_size = -1;
1271
1272                                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ARTWORK_MIME, &p, &artwork_mime_size, NULL);
1273                                         if ((mmf_error == MM_ERROR_NONE) && (artwork_mime_size > 0)) {
1274                                                 result = _media_svc_get_thumbnail_path(content_info->storage_type, thumb_path, content_info->path, p);
1275                                                 if (result == FALSE) {
1276                                                         media_svc_error("Fail to Get Thumbnail Path");
1277                                                 }
1278                                         } else {
1279                                                 SAFE_FREE(err_attr_name);
1280                                         }
1281
1282                                         if(strlen(thumb_path) > 0)
1283                                         {
1284                                                 ret = _media_svc_save_image(image, size, thumb_path);
1285                                                 if (ret != MEDIA_INFO_ERROR_NONE) {
1286                                                         media_svc_error("Fail to Save Thumbnail Image");
1287                                                 }
1288                                                 else {
1289                                                         ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
1290                                                         if(ret != MEDIA_INFO_ERROR_NONE)
1291                                                                 media_svc_error("strcpy error");
1292                                                 }
1293                                         }
1294                                 }
1295                         }
1296
1297                         if(append_album == TRUE) {
1298
1299                                 if((strncmp(content_info->media_meta.album, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))) &&
1300                                         (strncmp(content_info->media_meta.artist, MEDIA_SVC_TAG_UNKNOWN, strlen(MEDIA_SVC_TAG_UNKNOWN))))
1301                                         ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, content_info->thumbnail_path, &album_id);
1302                                 else
1303                                         ret = _media_svc_append_album(handle, content_info->media_meta.album, content_info->media_meta.artist, NULL, &album_id);
1304
1305                                 content_info->album_id = album_id;
1306                         }
1307                 } else if(media_type == MEDIA_SVC_MEDIA_TYPE_VIDEO) {
1308                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_LONGITUDE, &gps_value, NULL);
1309                         if (mmf_error == MM_ERROR_NONE) {
1310                                 if (gps_value == 0.0)
1311                                         content_info->media_meta.longitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
1312                                 else
1313                                         content_info->media_meta.longitude = gps_value;
1314                         } else {
1315                                 SAFE_FREE(err_attr_name);
1316                         }
1317
1318                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_LATIDUE, &gps_value, NULL);
1319                         if (mmf_error == MM_ERROR_NONE) {
1320                                 if (gps_value == 0.0)
1321                                         content_info->media_meta.latitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
1322                                 else
1323                                         content_info->media_meta.latitude = gps_value;
1324                         } else {
1325                                 SAFE_FREE(err_attr_name);
1326                         }
1327
1328                         mmf_error = mm_file_get_attrs(tag, &err_attr_name, MM_FILE_TAG_ALTIDUE, &gps_value, NULL);
1329                         if (mmf_error == MM_ERROR_NONE) {
1330                                 if (gps_value == 0.0)
1331                                         content_info->media_meta.altitude = MEDIA_SVC_DEFAULT_GPS_VALUE;
1332                                 else
1333                                         content_info->media_meta.altitude = gps_value;
1334                         } else {
1335                                 SAFE_FREE(err_attr_name);
1336                         }
1337 #if 0
1338                         //if ((!thumb_extracted_from_drm) && (extract_thumbnail == TRUE))
1339                         {
1340                                 /* Extracting thumbnail */
1341                                 char thumb_path[MEDIA_SVC_PATHNAME_SIZE + 1] = {0, };
1342                                 int width = 0;
1343                                 int height = 0;
1344
1345                                 ret = thumbnail_request_from_db_with_size(content_info->path, thumb_path, sizeof(thumb_path), &width, &height);
1346                                 if (ret < 0) {
1347                                         media_svc_error("thumbnail_request_from_db failed: %d", ret);
1348                                 } else {
1349                                         //media_svc_debug("thumbnail_request_from_db success: %s", thumb_path);
1350                                 }
1351
1352                                 ret = __media_svc_malloc_and_strncpy(&content_info->thumbnail_path, thumb_path);
1353                                 if(ret != MEDIA_INFO_ERROR_NONE)
1354                                         media_svc_error("strcpy error");
1355
1356                                 if (content_info->media_meta.width <= 0) content_info->media_meta.width = width;
1357                                 if (content_info->media_meta.height <= 0) content_info->media_meta.height = height;
1358                         }
1359 #endif
1360                 }
1361
1362                 mmf_error = mm_file_destroy_tag_attrs(tag);
1363                 if (mmf_error != MM_ERROR_NONE) {
1364                         media_svc_error("fail to free tag attr - err(%x)", mmf_error);
1365                 }
1366         }       else {
1367                 /* in case of file size 0, MMFW Can't parsting tag info but add it to Music DB. */
1368                 char *title = NULL;
1369                 media_svc_error("no tag information");
1370
1371                 title = _media_svc_get_title_from_filepath(content_info->path);
1372                 if (title) {
1373                         ret = __media_svc_malloc_and_strncpy(&content_info->media_meta.title, title);
1374                         if(ret != MEDIA_INFO_ERROR_NONE)
1375                                 media_svc_error("strcpy error");
1376                         SAFE_FREE(title);
1377                 } else {
1378                         media_svc_error("Can't extract title from filepath [%s]", content_info->path);
1379                 }
1380
1381                 content_info->album_id = album_id;
1382         }
1383
1384         return MEDIA_INFO_ERROR_NONE;
1385 }
1386
1387 void _media_svc_destroy_content_info(media_svc_content_info_s *content_info)
1388 {
1389         media_svc_retm_if(content_info == NULL, "content info is NULL");
1390
1391         /* Delete media_svc_content_info_s */
1392         SAFE_FREE(content_info->media_uuid);
1393         SAFE_FREE(content_info->path);
1394         SAFE_FREE(content_info->file_name);
1395         SAFE_FREE(content_info->mime_type);
1396         SAFE_FREE(content_info->folder_uuid);
1397         SAFE_FREE(content_info->thumbnail_path);
1398
1399         /* Delete media_svc_content_meta_s */
1400         SAFE_FREE(content_info->media_meta.title);
1401         SAFE_FREE(content_info->media_meta.album);
1402         SAFE_FREE(content_info->media_meta.artist);
1403         SAFE_FREE(content_info->media_meta.genre);
1404         SAFE_FREE(content_info->media_meta.composer);
1405         SAFE_FREE(content_info->media_meta.year);
1406         SAFE_FREE(content_info->media_meta.recorded_date);
1407         SAFE_FREE(content_info->media_meta.copyright);
1408         SAFE_FREE(content_info->media_meta.track_num);
1409         SAFE_FREE(content_info->media_meta.description);
1410         SAFE_FREE(content_info->media_meta.datetaken);
1411
1412         return;
1413 }
1414
1415 int _media_svc_get_store_type_by_path(const char *path, media_svc_storage_type_e *storage_type)
1416 {
1417         if(STRING_VALID(path))
1418         {
1419                 if(strncmp(path, MEDIA_SVC_PATH_PHONE, strlen(MEDIA_SVC_PATH_PHONE)) == 0)
1420                 {
1421                         *storage_type = MEDIA_SVC_STORAGE_INTERNAL;
1422                 }
1423                 else if(strncmp (path, MEDIA_SVC_PATH_MMC, strlen(MEDIA_SVC_PATH_MMC)) == 0)
1424                 {
1425                         *storage_type = MEDIA_SVC_STORAGE_EXTERNAL;
1426                 }
1427         }
1428         else
1429         {
1430                 media_svc_error("INVALID parameter");
1431                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1432         }
1433
1434         return MEDIA_INFO_ERROR_NONE;
1435 }
1436
1437 char *_media_svc_replace_path(char *s, const char *olds, const char *news)
1438 {
1439   char *result, *sr;
1440   size_t i, count = 0;
1441   size_t oldlen = strlen(olds); if (oldlen < 1) return s;
1442   size_t newlen = strlen(news);
1443
1444   if (newlen != oldlen) {
1445     for (i = 0; s[i] != '\0';) {
1446       if (memcmp(&s[i], olds, oldlen) == 0) count++, i += oldlen;
1447       else i++;
1448     }
1449   } else i = strlen(s);
1450
1451
1452   result = (char *) calloc(1, i + 1 + count * (newlen - oldlen));
1453   if (result == NULL) return NULL;
1454
1455   sr = result;
1456   while (*s) {
1457     if (memcmp(s, olds, oldlen) == 0) {
1458       memcpy(sr, news, newlen);
1459       sr += newlen;
1460       s  += oldlen;
1461     } else *sr++ = *s++;
1462   }
1463
1464   *sr = '\0';
1465
1466   return result;
1467 }
1468
1469 int _media_svc_error_convert(int error)
1470 {
1471         media_svc_debug("error : [%d]", error);
1472
1473         if(error == MS_MEDIA_ERR_NONE)                                                  /*Error None*/
1474                 return MEDIA_INFO_ERROR_NONE;
1475         else if(error == MS_MEDIA_ERR_DB_CONNECT_FAIL)                  /*DB Connect Fail*/
1476                 return MEDIA_INFO_ERROR_DATABASE_CONNECT;
1477         else if(error == MS_MEDIA_ERR_DB_DISCONNECT_FAIL)               /*DB Disconnect Fail*/
1478                 return MEDIA_INFO_ERROR_DATABASE_DISCONNECT;
1479         else if(error == MS_MEDIA_ERR_SOCKET_CONN)                              /*Socket Connect Fail*/
1480                 return MEDIA_INFO_ERROR_SOCKET_CONN;
1481         else if(error == MS_MEDIA_ERR_INVALID_PARAMETER || error == MS_MEDIA_ERR_INVALID_PATH)
1482                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1483
1484         return MEDIA_INFO_ERROR_INTERNAL;
1485 }
1486
1487
1488 bool _media_svc_is_drm_file(const char *path)
1489 {
1490 #ifdef __SUPPORT_DRM
1491         int ret;
1492         drm_bool_type_e is_drm_file = DRM_UNKNOWN;
1493
1494         ret = drm_is_drm_file(path,&is_drm_file);
1495         if(DRM_RETURN_SUCCESS == ret && DRM_TRUE == is_drm_file)
1496                 return TRUE;
1497 #endif
1498         return FALSE;
1499 }
1500
1501 int _media_svc_get_mime_in_drm_info(const char *path, char *mime, drm_content_info_s **drm_contentInfo)
1502 {
1503 #ifdef __SUPPORT_DRM
1504         int ret = MEDIA_INFO_ERROR_NONE;
1505         drm_file_type_e file_type = DRM_TYPE_UNDEFINED;
1506
1507         if (path == NULL || mime == NULL)
1508                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1509
1510         ret = drm_get_file_type(path, &file_type);
1511         if (ret != DRM_RETURN_SUCCESS) {
1512                 media_svc_error("drm_get_file_type() failed : %d", ret);
1513                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1514         } else {
1515                 if (file_type == DRM_TYPE_OMA_V1
1516                 || file_type == DRM_TYPE_OMA_V2
1517                 || file_type == DRM_TYPE_OMA_PD) {
1518                         *drm_contentInfo = malloc(sizeof(drm_content_info_s));
1519                         memset(*drm_contentInfo,0x0,sizeof(drm_content_info_s));
1520                         ret = drm_get_content_info(path, *drm_contentInfo);
1521                         if (ret != DRM_RETURN_SUCCESS) {
1522                                 media_svc_error("drm_svc_get_content_info() fails :%d ", ret);
1523                                 free(*drm_contentInfo);
1524                                 *drm_contentInfo = NULL;
1525                                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1526                         }
1527
1528                         if (STRING_VALID((*drm_contentInfo)->mime_type)) {
1529                                 strncpy(mime,(*drm_contentInfo)->mime_type, MEDIA_SVC_METADATA_LEN_MAX);
1530                                 media_svc_debug("DRM contentType : %s",(*drm_contentInfo)->mime_type);
1531                         } else {
1532                                 free(*drm_contentInfo);
1533                                 *drm_contentInfo = NULL;
1534                                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1535                         }
1536                 } else {
1537                         media_svc_error("THIS IS DRM BUT YOU SHOULD USE API OF AUL LIBRARY");
1538                         *drm_contentInfo = NULL;
1539                         return MEDIA_INFO_ERROR_INVALID_MEDIA;
1540                 }
1541         }
1542
1543         return MEDIA_INFO_ERROR_NONE;
1544 #else
1545         *drm_contentInfo = NULL;
1546         return MEDIA_INFO_ERROR_INVALID_MEDIA;
1547 #endif
1548 }
1549
1550 int _media_svc_get_content_type_from_mime(const char * path, const char * mimetype, int * category)
1551 {
1552         int i = 0;
1553         int err = 0;
1554
1555         *category = MEDIA_SVC_CATEGORY_UNKNOWN;
1556
1557         //media_svc_debug("mime type : %s", mimetype);
1558
1559         /*categorize from mimetype */
1560         for (i = 0; i < CONTENT_TYPE_NUM; i++) {
1561                 if (strstr(mimetype, content_category[i].content_type) != NULL) {
1562                         *category = (*category | content_category[i].category_by_mime);
1563                         break;
1564                 }
1565         }
1566
1567         /*in application type, exitst sound file ex) x-smafs */
1568         if (*category & MEDIA_SVC_CATEGORY_ETC) {
1569                 int prefix_len = strlen(content_category[0].content_type);
1570
1571                 for (i = 0; i < SOUND_MIME_NUM; i++) {
1572                         if (strstr(mimetype + prefix_len, sound_mime_table[i]) != NULL) {
1573                                 *category ^= MEDIA_SVC_CATEGORY_ETC;
1574                                 *category |= MEDIA_SVC_CATEGORY_SOUND;
1575                                 break;
1576                         }
1577                 }
1578         }
1579
1580         /*check music file in soun files. */
1581         if (*category & MEDIA_SVC_CATEGORY_SOUND) {
1582                 int prefix_len = strlen(content_category[0].content_type) + 1;
1583
1584                 //media_svc_error("mime_type : %s", mimetype + prefix_len);
1585
1586                 for (i = 0; i < MUSIC_MIME_NUM; i++) {
1587                         if (strcmp(mimetype + prefix_len, music_mime_table[i]) == 0) {
1588                                 *category ^= MEDIA_SVC_CATEGORY_SOUND;
1589                                 *category |= MEDIA_SVC_CATEGORY_MUSIC;
1590                                 break;
1591                         }
1592                 }
1593
1594                 /*m3u file is playlist but mime type is "audio/x-mpegurl". but It has to be classified into MS_CATEGORY_ETC since playlist is not a sound track*/
1595                 if(strncasecmp(mimetype, "audio/x-mpegurl", strlen("audio/x-mpegurl")) == 0) {
1596                         *category ^= MEDIA_SVC_CATEGORY_SOUND;
1597                         *category |= MEDIA_SVC_CATEGORY_ETC;
1598                 }
1599         } else if (*category & MEDIA_SVC_CATEGORY_VIDEO) {
1600                 /*some video files don't have video stream. in this case it is categorize as music. */
1601                 char *ext;
1602                 /*"3gp" and "mp4" must check video stream and then categorize in directly. */
1603                 ext = strrchr(path, '.');
1604                 if (ext != NULL) {
1605                         if ((strncasecmp(ext, _3GP_FILE, 4) == 0) || (strncasecmp(ext, _MP4_FILE, 5) == 0)) {
1606                                 int audio = 0;
1607                                 int video = 0;
1608
1609                                 err = mm_file_get_stream_info(path, &audio, &video);
1610                                 if (err == 0) {
1611                                         if (audio > 0 && video == 0) {
1612                                                 *category ^= MEDIA_SVC_CATEGORY_VIDEO;
1613                                                 *category |= MEDIA_SVC_CATEGORY_MUSIC;
1614                                         }
1615                                 }
1616                         }
1617                 }
1618         }
1619
1620         //media_svc_debug("category_from_ext : %d", *category);
1621
1622         return err;
1623 }
1624
1625 /*
1626 drm_contentifo is not NULL, if the file is OMA DRM.
1627 If the file is not OMA DRM, drm_contentinfo must be NULL.
1628 */
1629 int _media_svc_get_mime_type(const char *path, char *mimetype, drm_bool_type_e *is_drm, drm_content_info_s **drm_contentInfo)
1630 {
1631         int ret = MEDIA_INFO_ERROR_NONE;
1632
1633         if (path == NULL)
1634                 return MEDIA_INFO_ERROR_INVALID_PARAMETER;
1635
1636 #ifdef __SUPPORT_DRM
1637         /* In case of drm file. */
1638         if (_media_svc_is_drm_file(path)) {
1639                 *is_drm = DRM_TRUE;
1640                 ret =  _media_svc_get_mime_in_drm_info(path, mimetype, drm_contentInfo);
1641                 if (ret == MEDIA_INFO_ERROR_NONE) {
1642                         return ret;
1643                 }
1644         }
1645 #else
1646         *is_drm = DRM_FALSE;
1647         *drm_contentInfo = NULL;
1648 #endif
1649
1650         /*in case of normal files or failure to get mime in drm */
1651         if (aul_get_mime_from_file(path, mimetype, 255) < 0) {
1652                 media_svc_error("aul_get_mime_from_file fail");
1653                 return MEDIA_INFO_ERROR_INVALID_MEDIA;
1654         }
1655
1656         return MEDIA_INFO_ERROR_NONE;
1657 }
1658
1659 int _media_svc_get_media_type(const char *path, const char *mime_type, media_svc_media_type_e *media_type)
1660 {
1661         int ret = MEDIA_INFO_ERROR_NONE;
1662         int category = 0;
1663
1664         media_svc_media_type_e type;
1665
1666         ret = _media_svc_get_content_type_from_mime(path, mime_type, &category);
1667         if (ret < 0) {
1668                 media_svc_error("_media_svc_get_content_type_from_mime failed : %d", ret);
1669         }
1670
1671         if (category & MEDIA_SVC_CATEGORY_SOUND)                type = MEDIA_SVC_MEDIA_TYPE_SOUND;
1672         else if (category & MEDIA_SVC_CATEGORY_MUSIC)   type = MEDIA_SVC_MEDIA_TYPE_MUSIC;
1673         else if (category & MEDIA_SVC_CATEGORY_IMAGE)   type = MEDIA_SVC_MEDIA_TYPE_IMAGE;
1674         else if (category & MEDIA_SVC_CATEGORY_VIDEO)   type = MEDIA_SVC_MEDIA_TYPE_VIDEO;
1675         else    type = MEDIA_SVC_MEDIA_TYPE_OTHER;
1676
1677         *media_type = type;
1678
1679         return ret;
1680 }
1681