src/util/mtp_media_info.c

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <fcntl.h>
  20 #include <unistd.h>
  21 #include <glib.h>
  22 #include <glib/gprintf.h>
  23 #include <metadata_extractor.h>
  24 #include "mtp_media_info.h"
  25 #include "mtp_util.h"
  26 #include "mtp_support.h"
  27 #include "mtp_fs.h"
  28
  29 static bool __fill_media_id_cb(media_info_h media, void *user_data)
  30 {
  31         media_info_h *media_id = (media_info_h *)user_data;
  32         DBG("INTO MEdia id retrieval callback");
  33         media_info_clone(media_id, media);
  34
  35         return FALSE;
  36 }
  37
  38 static void __scan_folder_cb(media_content_error_e err, void *user_data)
  39 {
  40         if (err != MEDIA_CONTENT_ERROR_NONE)
  41                 ERR("Scan folder callback returns error = [%d]\n", err);
  42
  43         return;
  44 }
  45
  46 mtp_bool _util_get_audio_metadata(const mtp_char *filepath,
  47                 comp_audio_meta_t *audio_data)
  48 {
  49         char *temp = NULL;
  50         audio_meta_h audio;
  51         filter_h filter = NULL;
  52         media_info_h media_item = NULL;
  53         mtp_int32 ret = MEDIA_CONTENT_ERROR_NONE;
  54         mtp_char condition[MEDIA_PATH_COND_MAX_LEN + 1];
  55
  56         retv_if(filepath == NULL, FALSE);
  57         retv_if(audio_data == NULL, FALSE);
  58
  59         g_snprintf(condition, MEDIA_PATH_COND_MAX_LEN + 1, "%s\"%s\"",
  60                         MEDIA_PATH_COND, filepath);
  61
  62         ret = media_filter_create(&filter);
  63         if (ret != MEDIA_CONTENT_ERROR_NONE) {
  64                 ERR("Fail to create filter ");
  65                 return FALSE;
  66         }
  67
  68         ret = media_filter_set_condition(filter, condition,
  69                         MEDIA_CONTENT_COLLATE_DEFAULT);
  70         if (ret != MEDIA_CONTENT_ERROR_NONE) {
  71                 ERR("Failed to set condition ");
  72                 media_filter_destroy(filter);
  73                 return FALSE;
  74         }
  75
  76         ret = media_info_foreach_media_from_db(filter, __fill_media_id_cb,
  77                         &media_item);
  78         if (ret != MEDIA_CONTENT_ERROR_NONE) {
  79                 ERR("media_info_foreach_media_from_db Fail");
  80                 media_filter_destroy(filter);
  81                 return FALSE;
  82         }
  83
  84         media_filter_destroy(filter);
  85
  86         if (media_item == NULL) {
  87                 ERR("File entry not found in db");
  88                 return FALSE;
  89         }
  90
  91         ret = media_info_get_audio(media_item, &audio);
  92         if (ret != MEDIA_CONTENT_ERROR_NONE || audio == NULL) {
  93                 ERR("media_info_get_audio Fail or Audio is NULL");
  94                 media_info_destroy(media_item);
  95                 return FALSE;
  96         }
  97
  98         ret = audio_meta_get_album(audio, &(audio_data->commonmeta.album));
  99         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 100                 ERR("METADATA_ALBUM Fail");
 101                 goto ERROR_EXIT;
 102         }
 103
 104         ret = audio_meta_get_artist(audio, &(audio_data->commonmeta.artist));
 105         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 106                 ERR("METADATA_ARTIST Fail");
 107                 goto ERROR_EXIT;
 108         }
 109
 110         ret = audio_meta_get_bit_rate(audio,
 111                         &(audio_data->commonmeta.audio_bitrate));
 112         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 113                 ERR("METADATA_AUDIO_BITRATE Fail");
 114                 goto ERROR_EXIT;
 115         }
 116
 117         ret = audio_meta_get_composer(audio, &(audio_data->commonmeta.author));
 118         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 119                 ERR("METADATA_AUTHOR Fail");
 120                 goto ERROR_EXIT;
 121         }
 122
 123         ret = audio_meta_get_copyright(audio,
 124                         &(audio_data->commonmeta.copyright));
 125         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 126                 ERR("METADATA_COPYRIGHT Fail");
 127                 goto ERROR_EXIT;
 128         }
 129
 130         ret = audio_meta_get_duration(audio,
 131                         &(audio_data->commonmeta.duration));
 132         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 133                 ERR("METADATA_DURATION Fail");
 134                 goto ERROR_EXIT;
 135         }
 136
 137         ret = audio_meta_get_genre(audio, &(audio_data->commonmeta.genre));
 138         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 139                 ERR("METADATA_GENRE Fail");
 140                 goto ERROR_EXIT;
 141         }
 142
 143         ret = audio_meta_get_recorded_date(audio,
 144                         &(audio_data->commonmeta.year));
 145         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 146                 ERR("METADATA_RECDATE Fail");
 147                 goto ERROR_EXIT;
 148         }
 149
 150         ret = audio_meta_get_track_num(audio, &temp);
 151         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 152                 ERR("METADATA_TRACK_NUM Fail");
 153                 goto ERROR_EXIT;
 154         }
 155
 156         if (NULL != temp) {
 157                 audio_data->audiometa.track = atoi(temp);
 158                 MTP_PAL_SAFE_FREE(temp);
 159         }
 160
 161         ret = audio_meta_get_channel(audio,
 162                         &(audio_data->commonmeta.num_channel));
 163         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 164                 ERR("METADATA_NUM_CHANNEL Fail");
 165                 goto ERROR_EXIT;
 166         }
 167
 168         ret = audio_meta_get_sample_rate(audio,
 169                         &(audio_data->commonmeta.sample_rate));
 170         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 171                 ERR("METADATA_SAMPLE_RATE Fail");
 172                 goto ERROR_EXIT;
 173         }
 174
 175         audio_data->commonmeta.description = g_strdup("Unknown");
 176         audio_data->commonmeta.audio_codec = 0;
 177
 178         audio_meta_destroy(audio);
 179         media_info_destroy(media_item);
 180         return TRUE;
 181
 182 ERROR_EXIT:
 183
 184         audio_meta_destroy(audio);
 185         media_info_destroy(media_item);
 186         return FALSE;
 187 }
 188
 189 mtp_bool _util_get_video_metadata(mtp_char *filepath,
 190                 comp_video_meta_t *video_data)
 191 {
 192         filter_h filter = NULL;
 193         video_meta_h video;
 194         media_info_h media_item = NULL;
 195         mtp_int32 ret = MEDIA_CONTENT_ERROR_NONE;
 196         mtp_char condition[MEDIA_PATH_COND_MAX_LEN + 1];
 197
 198         retv_if(filepath == NULL, FALSE);
 199         retv_if(video_data == NULL, FALSE);
 200
 201         g_snprintf(condition, sizeof(condition), "%s\"%s\"", MEDIA_PATH_COND, filepath);
 202
 203         ret = media_filter_create(&filter);
 204         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 205                 ERR("Fail to create filter ");
 206                 return FALSE;
 207         }
 208
 209         ret = media_filter_set_condition(filter, condition,
 210                         MEDIA_CONTENT_COLLATE_DEFAULT);
 211         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 212                 ERR("Failed to set condition ");
 213                 media_filter_destroy(filter);
 214                 return FALSE;
 215         }
 216
 217         ret = media_info_foreach_media_from_db(filter, __fill_media_id_cb,
 218                         &media_item);
 219         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 220                 ERR("media_info_foreach_media_from_db Fail");
 221                 media_filter_destroy(filter);
 222                 return FALSE;
 223         }
 224
 225         media_filter_destroy(filter);
 226
 227         if (media_item == NULL) {
 228                 ERR("File entry not found in db");
 229                 return FALSE;
 230         }
 231
 232         ret = media_info_get_video(media_item, &video);
 233         if (ret != MEDIA_CONTENT_ERROR_NONE || video == NULL) {
 234                 ERR("media_info_get_audio Fail or video is NULL");
 235                 media_info_destroy(media_item);
 236                 return FALSE;
 237         }
 238
 239         ret = video_meta_get_album(video, &(video_data->commonmeta.album));
 240         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 241                 ERR("METADATA_ALBUM Fail");
 242                 goto ERROR_EXIT;
 243         }
 244
 245         ret = video_meta_get_artist(video, &(video_data->commonmeta.artist));
 246         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 247                 ERR("METADATA_ARTIST Fail");
 248                 goto ERROR_EXIT;
 249         }
 250
 251         /* AUDIO BITRATE */
 252         video_data->commonmeta.audio_bitrate = 0;
 253
 254         ret = video_meta_get_composer(video, &(video_data->commonmeta.author));
 255         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 256                 ERR("METADATA_AUTHOR Fail");
 257                 goto ERROR_EXIT;
 258         }
 259
 260         ret = video_meta_get_copyright(video,
 261                         &(video_data->commonmeta.copyright));
 262         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 263                 ERR("METADATA_COPYRIGHT Fail");
 264                 goto ERROR_EXIT;
 265         }
 266
 267         /* Description */
 268         video_data->commonmeta.description = g_strdup("Unknown");
 269
 270         ret = video_meta_get_duration(video,
 271                         &(video_data->commonmeta.duration));
 272         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 273                 ERR("METADATA_DURATION Fail");
 274                 goto ERROR_EXIT;
 275         }
 276
 277         ret = video_meta_get_genre(video, &(video_data->commonmeta.genre));
 278         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 279                 ERR("METADATA_GENRE Fail");
 280                 goto ERROR_EXIT;
 281         }
 282
 283         ret = video_meta_get_recorded_date(video,
 284                         &(video_data->commonmeta.year));
 285         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 286                 ERR("METADATA_REC_DATE Fail");
 287                 goto ERROR_EXIT;
 288         }
 289
 290         /* METADATA_AUDIO_CHANNELS */
 291         video_data->commonmeta.num_channel = 0;
 292
 293         /* METADAT_RATING */
 294         video_data->commonmeta.rating = 0;
 295
 296         /* METADATA_SAMPLE_RATE */
 297         video_data->commonmeta.sample_rate = 0;
 298
 299         ret = video_meta_get_track_num(video, &(video_data->videometa.track));
 300         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 301                 ERR("METADATA_TRACK_NUM Fail");
 302                 goto ERROR_EXIT;
 303         }
 304
 305         ret = video_meta_get_bit_rate(video, &(video_data->videometa.video_br));
 306         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 307                 ERR("METADATA_VIDEO_BITRATE Fail");
 308                 goto ERROR_EXIT;
 309         }
 310
 311         /* VIDEO_FPS */
 312         video_data->videometa.video_fps = 0;
 313         video_data->commonmeta.audio_codec = 0;
 314         video_data->videometa.video_br = 0;
 315
 316         ret = video_meta_get_height(video, &(video_data->videometa.video_h));
 317         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 318                 ERR("METADATA_HEIGHT Fail");
 319                 goto ERROR_EXIT;
 320         }
 321
 322         ret = video_meta_get_width(video, &(video_data->videometa.video_w));
 323         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 324                 ERR("METADATA_WIDTH Fail");
 325                 goto ERROR_EXIT;
 326         }
 327
 328         video_meta_destroy(video);
 329         media_info_destroy(media_item);
 330         return TRUE;
 331 ERROR_EXIT:
 332         video_meta_destroy(video);
 333         media_info_destroy(media_item);
 334
 335         return FALSE;
 336 }
 337
 338 static media_info_h __util_find_media_info(mtp_char *condition)
 339 {
 340         int ret;
 341         filter_h filter = NULL;
 342         media_info_h media_item = NULL;
 343
 344         ret = media_filter_create(&filter);
 345         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 346                 ERR("Fail to create filter ");
 347                 return NULL;
 348         }
 349
 350         do {
 351                 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 352                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 353                         ERR("media_filter_set_condition() Fail");
 354                         break;
 355                 }
 356
 357                 ret = media_filter_set_offset(filter, 0, 1);
 358                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 359                         ERR("media_filter_set_offset() Fail");
 360                         break;
 361                 }
 362
 363                 ret = media_info_foreach_media_from_db(filter, __fill_media_id_cb, &media_item);
 364                 if (ret != MEDIA_CONTENT_ERROR_NONE) {
 365                         ERR("media_info_foreach_media_from_db() Fail");
 366                         break;
 367                 }
 368         } while (0);
 369
 370         media_filter_destroy(filter);
 371
 372         return media_item;
 373 }
 374
 375
 376 static mtp_bool __util_get_height_width(image_meta_h image, int *h, int *w)
 377 {
 378         int ret;
 379
 380         ret = image_meta_get_height(image, h);
 381         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 382                 ERR("image_meta_get_height() Fail(%d)", ret);
 383                 return FALSE;
 384         }
 385
 386         ret = image_meta_get_width(image, w);
 387         if (ret != MEDIA_CONTENT_ERROR_NONE) {
 388                 ERR("image_meta_get_width() Fail(%d)", ret);
 389                 return FALSE;
 390         }
 391
 392         return TRUE;
 393 }
 394
 395 mtp_bool _util_get_image_ht_wt(const mtp_char *filepath,
 396                 image_meta_t *image_data)
 397 {
 398         mtp_int32 ret;
 399         image_meta_h image;
 400         media_info_h media_item;
 401         mtp_char condition[MEDIA_PATH_COND_MAX_LEN + 1];
 402
 403         retv_if(filepath == NULL, FALSE);
 404         retv_if(image_data == NULL, FALSE);
 405
 406         g_snprintf(condition, sizeof(condition), "%s\"%s\"", MEDIA_PATH_COND, filepath);
 407
 408         media_item = __util_find_media_info(condition);
 409         if (media_item == NULL) {
 410                 ERR("File entry not found in db");
 411                 return FALSE;
 412         }
 413
 414         ret = media_info_get_image(media_item, &image);
 415         if (ret != MEDIA_CONTENT_ERROR_NONE || image == NULL) {
 416                 ERR("media_info_get_image() Fail(%d) or image(%p) is NULL", ret, image);
 417                 media_info_destroy(media_item);
 418                 return FALSE;
 419         }
 420
 421         ret = __util_get_height_width(image, &image_data->ht, &image_data->wt);
 422         if (FALSE == ret)
 423                 ERR("__util_get_height_width() Fail");
 424
 425         media_info_destroy(media_item);
 426         image_meta_destroy(image);
 427
 428         return ret;
 429 }
 430
 431 mtp_bool _util_get_audio_meta_from_extractor(const mtp_char *filepath,
 432                 comp_audio_meta_t *audio_data)
 433 {
 434         mtp_int32 ret = 0;
 435         mtp_char *temp = NULL;
 436         metadata_extractor_h metadata = NULL;
 437
 438         retv_if(filepath == NULL, FALSE);
 439         retv_if(audio_data == NULL, FALSE);
 440
 441         ret = metadata_extractor_create(&metadata);
 442         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 443                 ERR("metadata extractor create Fail");
 444                 return FALSE;
 445         }
 446
 447         ret = metadata_extractor_set_path(metadata, filepath);
 448         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 449                 ERR("metadata extractor set path Fail");
 450                 goto ERROR_EXIT;
 451         }
 452
 453         ret = metadata_extractor_get_metadata(metadata, METADATA_ALBUM,
 454                         &(audio_data->commonmeta.album));
 455         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 456                 ERR("METADATA_ALBUM Fail");
 457                 goto ERROR_EXIT;
 458         }
 459
 460         ret = metadata_extractor_get_metadata(metadata, METADATA_ARTIST,
 461                         &(audio_data->commonmeta.artist));
 462         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 463                 ERR("METADATA_ARTIST Fail");
 464                 goto ERROR_EXIT;
 465         }
 466
 467         ret = metadata_extractor_get_metadata(metadata, METADATA_AUDIO_BITRATE,
 468                         &temp);
 469         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 470                 ERR("METADATA_AUDIO_BITRATE Fail");
 471                 goto ERROR_EXIT;
 472         }
 473
 474         if (NULL != temp) {
 475                 audio_data->commonmeta.audio_bitrate = atoi(temp);
 476                 MTP_PAL_SAFE_FREE(temp);
 477         }
 478
 479         ret = metadata_extractor_get_metadata(metadata, METADATA_AUTHOR,
 480                         &(audio_data->commonmeta.author));
 481         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 482                 ERR("METADATA_AUTHOR Fail");
 483                 goto ERROR_EXIT;
 484         }
 485
 486         ret = metadata_extractor_get_metadata(metadata, METADATA_COPYRIGHT,
 487                         &(audio_data->commonmeta.copyright));
 488         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 489                 ERR("METADATA_COPYRIGHT Fail");
 490                 goto ERROR_EXIT;
 491         }
 492
 493         ret = metadata_extractor_get_metadata(metadata, METADATA_DESCRIPTION,
 494                         &(audio_data->commonmeta.description));
 495         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 496                 ERR("METADATA_DESCRIPTION Fail");
 497                 goto ERROR_EXIT;
 498         }
 499
 500         ret = metadata_extractor_get_metadata(metadata, METADATA_DURATION,
 501                         &temp);
 502         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 503                 ERR("METADATA_DURATION Fail");
 504                 goto ERROR_EXIT;
 505         }
 506
 507         if (NULL != temp) {
 508                 audio_data->commonmeta.duration = atoi(temp);
 509                 MTP_PAL_SAFE_FREE(temp);
 510         }
 511
 512         ret = metadata_extractor_get_metadata(metadata, METADATA_GENRE,
 513                         &(audio_data->commonmeta.genre));
 514         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 515                 ERR("METADATA_GENRE Fail");
 516                 goto ERROR_EXIT;
 517         }
 518
 519         ret = metadata_extractor_get_metadata(metadata, METADATA_RECDATE,
 520                         &(audio_data->commonmeta.year));
 521         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 522                 ERR("METADATA_RECDATE Fail");
 523                 goto ERROR_EXIT;
 524         }
 525
 526         ret = metadata_extractor_get_metadata(metadata, METADATA_TRACK_NUM,
 527                         &temp);
 528         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 529                 ERR("METADATA_TRACK_NUM Fail");
 530                 goto ERROR_EXIT;
 531         }
 532         if (NULL != temp) {
 533                 audio_data->audiometa.track = atoi(temp);
 534                 MTP_PAL_SAFE_FREE(temp);
 535         }
 536
 537         ret = metadata_extractor_get_metadata(metadata, METADATA_RATING,
 538                         &temp);
 539         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 540                 ERR("METADATA_RATING Fail");
 541                 goto ERROR_EXIT;
 542         }
 543         if (NULL != temp) {
 544                 audio_data->commonmeta.rating = atoi(temp);
 545                 MTP_PAL_SAFE_FREE(temp);
 546         }
 547
 548         ret = metadata_extractor_get_metadata(metadata,
 549                         METADATA_AUDIO_SAMPLERATE, &temp);
 550         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 551                 ERR("METADATA_SAMPLERATE Fail");
 552                 goto ERROR_EXIT;
 553         }
 554         if (NULL != temp) {
 555                 audio_data->commonmeta.sample_rate = atoi(temp);
 556                 MTP_PAL_SAFE_FREE(temp);
 557         }
 558
 559         ret = metadata_extractor_get_metadata(metadata, METADATA_AUDIO_CHANNELS,
 560                         &temp);
 561         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 562                 ERR("METADATA_CHANNELS Fail");
 563                 goto ERROR_EXIT;
 564         }
 565         if (NULL != temp) {
 566                 audio_data->commonmeta.num_channel = atoi(temp);
 567                 MTP_PAL_SAFE_FREE(temp);
 568         }
 569
 570         audio_data->commonmeta.audio_codec = 0;
 571
 572         metadata_extractor_destroy(metadata);
 573         return TRUE;
 574
 575 ERROR_EXIT:
 576         metadata_extractor_destroy(metadata);
 577         return FALSE;
 578 }
 579
 580 mtp_bool _util_get_video_meta_from_extractor(const mtp_char *filepath,
 581                 comp_video_meta_t *video_data)
 582 {
 583         mtp_int32 ret = 0;
 584         mtp_char *temp = NULL;
 585         metadata_extractor_h metadata = NULL;
 586
 587         retv_if(filepath == NULL, FALSE);
 588         retv_if(video_data == NULL, FALSE);
 589
 590         ret = metadata_extractor_create(&metadata);
 591         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 592                 ERR("metadata extractor create Fail");
 593                 return FALSE;
 594         }
 595
 596         ret = metadata_extractor_set_path(metadata, filepath);
 597         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 598                 ERR("metadata extractor set path Fail");
 599                 goto ERROR_EXIT;
 600         }
 601
 602         ret = metadata_extractor_get_metadata(metadata, METADATA_ALBUM,
 603                         &(video_data->commonmeta.album));
 604         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 605                 ERR("METADATA_ALBUM Fail");
 606                 goto ERROR_EXIT;
 607
 608         }
 609
 610         ret = metadata_extractor_get_metadata(metadata, METADATA_ARTIST,
 611                         &(video_data->commonmeta.artist));
 612         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 613                 ERR("METADATA_ARTIST Fail");
 614                 goto ERROR_EXIT;
 615         }
 616
 617         ret = metadata_extractor_get_metadata(metadata, METADATA_AUDIO_BITRATE,
 618                         &temp);
 619         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 620                 ERR("METADATA_AUDIO_BITRATE Fail");
 621                 goto ERROR_EXIT;
 622         }
 623         if (NULL != temp) {
 624                 video_data->commonmeta.audio_bitrate = atoi(temp);
 625                 MTP_PAL_SAFE_FREE(temp);
 626         }
 627
 628         ret = metadata_extractor_get_metadata(metadata, METADATA_AUTHOR,
 629                         &(video_data->commonmeta.author));
 630         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 631                 ERR("METADATA_AUTHOR Fail");
 632                 goto ERROR_EXIT;
 633         }
 634
 635         ret = metadata_extractor_get_metadata(metadata, METADATA_COPYRIGHT,
 636                         &(video_data->commonmeta.copyright));
 637         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 638                 ERR("METADATA_COPYRIGHT Fail");
 639                 goto ERROR_EXIT;
 640         }
 641
 642         ret = metadata_extractor_get_metadata(metadata, METADATA_DESCRIPTION,
 643                         &(video_data->commonmeta.description));
 644         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 645                 ERR("METADATA_DESCRIPTION Fail");
 646                 goto ERROR_EXIT;
 647         }
 648
 649         ret = metadata_extractor_get_metadata(metadata, METADATA_DURATION,
 650                         &temp);
 651         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 652                 ERR("METADATA_DURATION Fail");
 653                 goto ERROR_EXIT;
 654         }
 655         if (NULL != temp) {
 656                 video_data->commonmeta.duration = atoi(temp);
 657                 MTP_PAL_SAFE_FREE(temp);
 658         }
 659
 660         ret = metadata_extractor_get_metadata(metadata, METADATA_GENRE,
 661                         &(video_data->commonmeta.genre));
 662         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 663                 ERR("METADATA_GENRE Fail");
 664                 goto ERROR_EXIT;
 665         }
 666
 667         ret = metadata_extractor_get_metadata(metadata, METADATA_RECDATE,
 668                         &(video_data->commonmeta.year));
 669         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 670                 ERR("METADATA_RECDATE Fail");
 671                 goto ERROR_EXIT;
 672         }
 673
 674         ret = metadata_extractor_get_metadata(metadata, METADATA_AUDIO_CHANNELS,
 675                         &temp);
 676         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 677                 ERR("METADATA_AUDIO_CHANNELS Fail");
 678                 goto ERROR_EXIT;
 679         }
 680         if (NULL != temp) {
 681                 video_data->commonmeta.num_channel = atoi(temp);
 682                 MTP_PAL_SAFE_FREE(temp);
 683         }
 684
 685         ret = metadata_extractor_get_metadata(metadata, METADATA_RATING,
 686                         &temp);
 687         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 688                 ERR("METADATA_RATING Fail");
 689                 goto ERROR_EXIT;
 690         }
 691
 692         if (NULL != temp) {
 693                 video_data->commonmeta.rating = atoi(temp);
 694                 MTP_PAL_SAFE_FREE(temp);
 695         }
 696
 697         ret = metadata_extractor_get_metadata(metadata,
 698                         METADATA_AUDIO_SAMPLERATE, &temp);
 699         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 700                 ERR("METADATA_AUDIO_SAMPLERATE Fail");
 701                 goto ERROR_EXIT;
 702         }
 703         if (NULL != temp) {
 704                 video_data->commonmeta.sample_rate = atoi(temp);
 705                 MTP_PAL_SAFE_FREE(temp);
 706         }
 707
 708         ret = metadata_extractor_get_metadata(metadata, METADATA_TRACK_NUM,
 709                         &(video_data->videometa.track));
 710         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 711                 ERR("METADATA_TRACK_NUM Fail");
 712                 goto ERROR_EXIT;
 713         }
 714
 715         ret = metadata_extractor_get_metadata(metadata, METADATA_VIDEO_BITRATE,
 716                         &temp);
 717         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 718                 ERR("METADATA_VIDEO_BITRATE Fail");
 719                 goto ERROR_EXIT;
 720         }
 721         if (NULL != temp) {
 722                 video_data->videometa.video_br = atoi(temp);
 723                 MTP_PAL_SAFE_FREE(temp);
 724         }
 725
 726         ret = metadata_extractor_get_metadata(metadata, METADATA_VIDEO_FPS,
 727                         &temp);
 728         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 729                 ERR("METADATA_VIDEO_FPS Fail");
 730                 goto ERROR_EXIT;
 731         }
 732         if (NULL != temp) {
 733                 video_data->videometa.video_fps = atoi(temp);
 734                 MTP_PAL_SAFE_FREE(temp);
 735         }
 736
 737         ret = metadata_extractor_get_metadata(metadata, METADATA_VIDEO_HEIGHT,
 738                         &temp);
 739         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 740                 ERR("METADATA_VIDEO_HEIGHT Fail");
 741                 goto ERROR_EXIT;
 742         }
 743         if (NULL != temp) {
 744                 video_data->videometa.video_h = atoi(temp);
 745                 MTP_PAL_SAFE_FREE(temp);
 746         }
 747
 748         ret = metadata_extractor_get_metadata(metadata, METADATA_VIDEO_WIDTH,
 749                         &temp);
 750         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 751                 ERR("METADATA_VIDEO_WIDTH Fail");
 752                 goto ERROR_EXIT;
 753         }
 754         if (NULL != temp) {
 755                 video_data->videometa.video_w = atoi(temp);
 756                 MTP_PAL_SAFE_FREE(temp);
 757         }
 758
 759         metadata_extractor_destroy(metadata);
 760         return TRUE;
 761
 762 ERROR_EXIT:
 763         metadata_extractor_destroy(metadata);
 764         return FALSE;
 765
 766 }
 767
 768 void _util_flush_db(void)
 769 {
 770         _util_add_file_to_db(NULL);
 771         _util_delete_file_from_db(NULL);
 772 }
 773
 774 void _util_delete_file_from_db(const mtp_char *filepath)
 775 {
 776         int ret;
 777         media_info_h info = NULL;
 778         char *media_id = NULL;
 779         mtp_char condition[MEDIA_PATH_COND_MAX_LEN + 1];
 780
 781         ret_if(NULL == filepath);
 782
 783         g_snprintf(condition, sizeof(condition), "%s\"%s\"", MEDIA_PATH_COND, filepath);
 784
 785         info = __util_find_media_info(condition);
 786         if (info == NULL) {
 787                 ERR("File entry not found in db");
 788                 return;
 789         }
 790
 791         ret = media_info_get_media_id(info, &media_id);
 792         if (MEDIA_CONTENT_ERROR_NONE != ret)
 793                 ERR("media_info_get_media_id() Fail(%d)", ret);
 794
 795         ret = media_info_delete_from_db(media_id);
 796         if (MEDIA_CONTENT_ERROR_NONE != ret)
 797                 ERR("media_info_delete_from_db() Fail(%d)", ret);
 798
 799         if (media_id)
 800                 free(media_id);
 801
 802         if (info)
 803                 media_info_destroy(info);
 804
 805         return;
 806 }
 807
 808 void _util_add_file_to_db(const mtp_char *filepath)
 809 {
 810         mtp_int32 ret;
 811         media_info_h info = NULL;
 812
 813         ret_if(NULL == filepath);
 814
 815         ret = media_info_insert_to_db(filepath, &info);
 816         if (MEDIA_CONTENT_ERROR_NONE != ret)
 817                 ERR("media_info_insert_to_db() Fail(%d)", ret);
 818
 819         if (info)
 820                 media_info_destroy(info);
 821
 822         return;
 823 }
 824
 825 void _util_scan_folder_contents_in_db(const mtp_char *filepath)
 826 {
 827         mtp_int32 ret;
 828
 829         ret_if(filepath == NULL);
 830
 831         ret = media_content_scan_folder(filepath, true, __scan_folder_cb, NULL);
 832         if (ret != MEDIA_CONTENT_ERROR_NONE)
 833                 ERR("media_content_scan_folder Fail : %d\n", ret);
 834
 835         return;
 836 }
 837
 838 void _util_free_common_meta(common_meta_t *metadata)
 839 {
 840         MTP_PAL_SAFE_FREE(metadata->album);
 841         MTP_PAL_SAFE_FREE(metadata->artist);
 842         MTP_PAL_SAFE_FREE(metadata->author);
 843         MTP_PAL_SAFE_FREE(metadata->copyright);
 844         MTP_PAL_SAFE_FREE(metadata->description);
 845         MTP_PAL_SAFE_FREE(metadata->genre);
 846         MTP_PAL_SAFE_FREE(metadata->year);
 847
 848         return;
 849 }
 850 void _util_free_video_meta(video_meta_t *video)
 851 {
 852         MTP_PAL_SAFE_FREE(video->track);
 853         return;
 854 }