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