src/metadata_extractor.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   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 <stdlib.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <mm_file.h>
  21 #include <metadata_extractor.h>
  22 #include <metadata_extractor_private.h>
  23
  24 #define SAFE_FREE(src)      { if(src) {free(src); src = NULL;}}
  25 #define META_MAX_LEN    256
  26
  27 typedef enum {
  28         METADATA_TYPE_STREAM    = 0,
  29         METADATA_TYPE_ATTR,
  30         METADATA_TYPE_TAG,
  31 } metadata_extractor_type_e;
  32
  33 static int __metadata_extractor_check_and_extract_meta(metadata_extractor_s *metadata, metadata_extractor_type_e metadata_type);
  34 static int __metadata_extractor_get_stream_info(metadata_extractor_s *metadata, const char *path);
  35 static int __metadata_extractor_create_content_attrs(metadata_extractor_s *metadata, const char *path);
  36 static int __metadata_extractor_create_tag_attr(metadata_extractor_s *metadata, const char *path);
  37 static int __metadata_extractor_create_content_attrs_from_buffer(metadata_extractor_s *metadata, const void *buffer, int size);
  38 static int __metadata_extractor_create_tag_attrs_from_buffer(metadata_extractor_s *metadata, const void *buffer, int size);
  39 static int __metadata_extractor_get_artwork(metadata_extractor_s *metadata, void **artwork, int *artwork_size);
  40 static int __metadata_extractor_get_artwork_mime(metadata_extractor_s *metadata, char **artwork_mime);
  41 static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s *metadata, void **thumbnail, int *thumbnail_len);
  42 static int __metadata_extractor_get_duration(metadata_extractor_s *metadata, int *duration);
  43 static int __metadata_extractor_get_audio_bitrate(metadata_extractor_s *metadata, int *bitrate);
  44 static int __metadata_extractor_get_audio_channel(metadata_extractor_s *metadata, int *channel);
  45 static int __metadata_extractor_get_audio_samplerate(metadata_extractor_s *metadata, int *samplerate);
  46 static int __metadata_extractor_get_audio_track_count(metadata_extractor_s *metadata, int *track_cnt);
  47 static int __metadata_extractor_get_video_bitrate(metadata_extractor_s *metadata, int *bitrate);
  48 static int __metadata_extractor_get_video_FPS(metadata_extractor_s *metadata, int *fps);
  49 static int __metadata_extractor_get_video_width(metadata_extractor_s *metadata, int *width);
  50 static int __metadata_extractor_get_video_height(metadata_extractor_s *metadata, int *height);
  51 static int __metadata_extractor_get_video_track_count(metadata_extractor_s *metadata, int *track_cnt);
  52 static int __metadata_extractor_get_artist(metadata_extractor_s *metadata, char **artist);
  53 static int __metadata_extractor_get_title(metadata_extractor_s *metadata, char **title);
  54 static int __metadata_extractor_get_album(metadata_extractor_s *metadata, char **album);
  55 static int __metadata_extractor_get_album_artist(metadata_extractor_s *metadata, char **album_artist);
  56 static int __metadata_extractor_get_genre(metadata_extractor_s *metadata, char **genre);
  57 static int __metadata_extractor_get_author(metadata_extractor_s *metadata, char **author);
  58 static int __metadata_extractor_get_copyright(metadata_extractor_s *metadata, char **copyright);
  59 static int __metadata_extractor_get_date(metadata_extractor_s *metadata, char **date);
  60 static int __metadata_extractor_get_description(metadata_extractor_s *metadata, char **description);
  61 static int __metadata_extractor_get_comment(metadata_extractor_s *metadata, char **comment);
  62 static int __metadata_extractor_get_track_num(metadata_extractor_s *metadata, char **track_num);
  63 static int __metadata_extractor_get_classification(metadata_extractor_s *metadata, char **classification);
  64 static int __metadata_extractor_get_rating(metadata_extractor_s *metadata, char **rating);
  65 static int __metadata_extractor_get_longitude(metadata_extractor_s *metadata, double *longitude);
  66 static int __metadata_extractor_get_latitude(metadata_extractor_s *metadata, double *latitude);
  67 static int __metadata_extractor_get_altitude(metadata_extractor_s *metadata, double *altitude);
  68 static int __metadata_extractor_get_conductor(metadata_extractor_s *metadata, char **conductor);
  69 static int __metadata_extractor_get_unsynclyrics(metadata_extractor_s *metadata, char **unsynclyrics);
  70 static int __metadata_extractor_get_recording_date(metadata_extractor_s *metadata, char **rec_date);
  71 static int __metadata_extractor_get_rotate(metadata_extractor_s *metadata, char **rotate);
  72 static int __metadata_extractor_get_synclyrics_pair_num(metadata_extractor_s *metadata, int *synclyrics_num);
  73 static int __metadata_extractor_destroy_handle(metadata_extractor_s *metadata);
  74
  75 static int __metadata_extractor_check_and_extract_meta(metadata_extractor_s *metadata, metadata_extractor_type_e metadata_type)
  76 {
  77         int ret = METADATA_EXTRACTOR_ERROR_NONE;
  78
  79         if ((!metadata) || ((!metadata->path) && (!metadata->buffer))) {
  80                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
  81                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
  82         }
  83
  84         if (metadata_type == METADATA_TYPE_STREAM) {
  85                 if ((metadata) && (metadata->attr_h)) {
  86                         return ret;
  87                 } else {
  88                         metadata_extractor_debug("Extract Stream Info");
  89                         ret = __metadata_extractor_get_stream_info(metadata, metadata->path);
  90                         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
  91                                 return ret;
  92                         }
  93                 }
  94         } else if (metadata_type == METADATA_TYPE_ATTR) {
  95                 if ((metadata) && (metadata->attr_h)) {
  96                         return ret;
  97                 } else {
  98                         metadata_extractor_debug("Extract Content attrs");
  99                         if (metadata->path != NULL) {
 100                                 ret = __metadata_extractor_create_content_attrs(metadata, metadata->path);
 101                                 if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 102                                         return ret;
 103                                 }
 104                         } else if (metadata->buffer != NULL) {
 105                                 ret = __metadata_extractor_create_content_attrs_from_buffer(metadata, metadata->buffer, metadata->buffer_size);
 106                                 if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 107                                         return ret;
 108                                 }
 109                         }
 110                 }
 111         } else if (metadata_type == METADATA_TYPE_TAG) {
 112                 if ((metadata) && (metadata->tag_h)) {
 113                         return ret;
 114                 } else {
 115                         metadata_extractor_debug("Extract Tag attrs");
 116                         if (metadata->path != NULL) {
 117                                 ret = __metadata_extractor_create_tag_attr(metadata, metadata->path);
 118                                 if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 119                                         return ret;
 120                                 }
 121                         } else if (metadata->buffer != NULL) {
 122                                 ret = __metadata_extractor_create_tag_attrs_from_buffer(metadata, metadata->buffer, metadata->buffer_size);
 123                                 if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
 124                                         return ret;
 125                                 }
 126                         }
 127                 }
 128         } else {
 129                 metadata_extractor_error("INVALID_PARAMETER(%d)", metadata_type);
 130                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 131         }
 132
 133         return ret;
 134 }
 135
 136 static int __metadata_extractor_get_stream_info(metadata_extractor_s *metadata, const char *path)
 137 {
 138         unsigned int ret = METADATA_EXTRACTOR_ERROR_NONE;
 139         int _audio_track_cnt = 0;
 140         int _video_track_cnt = 0;
 141
 142         ret = mm_file_get_stream_info(path, &_audio_track_cnt, &_video_track_cnt);
 143
 144         if (ret != FILEINFO_ERROR_NONE) {
 145                 if (ret == FILEINFO_ERROR_FILE_NOT_FOUND) {
 146                         metadata_extractor_error("FILE_NOT_EXISTS(0x%08x)", METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
 147                         return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
 148                 } else {
 149                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 150                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 151                 }
 152         }
 153
 154         metadata->audio_track_cnt = _audio_track_cnt;
 155         metadata->video_track_cnt = _video_track_cnt;
 156
 157         return ret;
 158 }
 159
 160 static int __metadata_extractor_create_content_attrs(metadata_extractor_s *metadata, const char *path)
 161 {
 162         unsigned int ret = METADATA_EXTRACTOR_ERROR_NONE;
 163         MMHandleType content = 0;
 164         char *err_attr_name = NULL;
 165
 166         int _audio_track_cnt = 0;
 167         int _video_track_cnt = 0;
 168
 169         ret = mm_file_create_content_attrs(&content, path);
 170
 171         if (ret != FILEINFO_ERROR_NONE) {
 172                 if (ret == FILEINFO_ERROR_FILE_NOT_FOUND) {
 173                         metadata_extractor_error("FILE_NOT_EXISTS(0x%08x)", METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
 174                         return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
 175                 } else {
 176                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 177                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 178                 }
 179         }
 180
 181         ret = mm_file_get_attrs(content, &err_attr_name,
 182                                 MM_FILE_CONTENT_VIDEO_TRACK_COUNT, &_video_track_cnt,
 183                                 MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &_audio_track_cnt,
 184                                 NULL);
 185
 186         if (ret != FILEINFO_ERROR_NONE) {
 187                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 188                 SAFE_FREE(err_attr_name);
 189                 mm_file_destroy_content_attrs(content);
 190                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 191         }
 192
 193         metadata->attr_h = content;
 194         metadata->audio_track_cnt = _audio_track_cnt;
 195         metadata->video_track_cnt = _video_track_cnt;
 196
 197         return ret;
 198
 199 }
 200
 201
 202 static int __metadata_extractor_create_tag_attr(metadata_extractor_s *metadata, const char *path)
 203 {
 204         unsigned int ret = METADATA_EXTRACTOR_ERROR_NONE;
 205         MMHandleType tag = 0;
 206
 207         ret = mm_file_create_tag_attrs(&tag, path);
 208
 209         if (ret != FILEINFO_ERROR_NONE) {
 210                 if (ret == FILEINFO_ERROR_FILE_NOT_FOUND) {
 211                         metadata_extractor_error("FILE_NOT_EXISTS(0x%08x)", METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
 212                         return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
 213                 } else {
 214                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 215                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 216                 }
 217         }
 218
 219         metadata->tag_h = tag;
 220
 221         return ret;
 222
 223 }
 224
 225 static int __metadata_extractor_create_content_attrs_from_buffer(metadata_extractor_s *metadata, const void *buffer, int size)
 226 {
 227         unsigned int ret = METADATA_EXTRACTOR_ERROR_NONE;
 228         MMHandleType content = 0;
 229         char *err_attr_name = NULL;
 230
 231         int _audio_track_cnt = 0;
 232         int _video_track_cnt = 0;
 233
 234         ret = mm_file_create_content_attrs_from_memory(&content, buffer, size, 0);
 235
 236         if (ret != FILEINFO_ERROR_NONE) {
 237                 if (ret == FILEINFO_ERROR_FILE_NOT_FOUND) {
 238                         metadata_extractor_error("FILE_NOT_EXISTS(0x%08x)", METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
 239                         return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
 240                 } else {
 241                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 242                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 243                 }
 244         }
 245
 246         ret = mm_file_get_attrs(content, &err_attr_name,
 247                                 MM_FILE_CONTENT_VIDEO_TRACK_COUNT, &_video_track_cnt,
 248                                 MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &_audio_track_cnt,
 249                                 NULL);
 250
 251         if (ret != FILEINFO_ERROR_NONE) {
 252                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 253                 SAFE_FREE(err_attr_name);
 254                 mm_file_destroy_content_attrs(content);
 255                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 256         }
 257
 258         metadata->attr_h = content;
 259         metadata->audio_track_cnt = _audio_track_cnt;
 260         metadata->video_track_cnt = _video_track_cnt;
 261
 262         return ret;
 263
 264 }
 265
 266 static int __metadata_extractor_create_tag_attrs_from_buffer(metadata_extractor_s *metadata, const void *buffer, int size)
 267 {
 268         unsigned int ret = METADATA_EXTRACTOR_ERROR_NONE;
 269         MMHandleType tag = 0;
 270
 271         ret = mm_file_create_tag_attrs_from_memory(&tag, buffer, size, 0);
 272
 273         if (ret != FILEINFO_ERROR_NONE) {
 274                 if (ret == FILEINFO_ERROR_FILE_NOT_FOUND) {
 275                         metadata_extractor_error("FILE_NOT_EXISTS(0x%08x)", METADATA_EXTRACTOR_ERROR_FILE_EXISTS);
 276                         return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
 277                 } else {
 278                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 279                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 280                 }
 281         }
 282
 283         metadata->tag_h = tag;
 284
 285         return ret;
 286
 287 }
 288
 289 static int __metadata_extractor_get_duration(metadata_extractor_s *metadata, int *duration)
 290 {
 291         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 292         char *err_attr_name = NULL;
 293         int _duration = 0;
 294
 295         if ((!metadata) || (!metadata->attr_h)) {
 296                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 297                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 298         }
 299
 300         ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_DURATION, &_duration, NULL);
 301         if (ret != FILEINFO_ERROR_NONE) {
 302                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 303                 SAFE_FREE(err_attr_name);
 304                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 305         }
 306
 307         *duration = _duration;
 308
 309         return ret;
 310 }
 311
 312 static int __metadata_extractor_get_audio_bitrate(metadata_extractor_s *metadata, int *bitrate)
 313 {
 314         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 315         char *err_attr_name = NULL;
 316         int _audio_bitrate = 0;
 317
 318         if ((!metadata) || (!metadata->attr_h)) {
 319                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 320                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 321         }
 322
 323         if (metadata->audio_track_cnt > 0) {
 324                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITRATE, &_audio_bitrate, NULL);
 325                 if (ret != FILEINFO_ERROR_NONE) {
 326                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 327                         SAFE_FREE(err_attr_name);
 328                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 329                 }
 330         }
 331
 332         *bitrate = _audio_bitrate;
 333
 334         return ret;
 335 }
 336
 337 static int __metadata_extractor_get_audio_channel(metadata_extractor_s *metadata, int *channel)
 338 {
 339         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 340         char *err_attr_name = NULL;
 341         int _audio_channel = 0;
 342
 343         if ((!metadata) || (!metadata->attr_h)) {
 344                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 345                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 346         }
 347
 348         if (metadata->audio_track_cnt > 0) {
 349                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_CHANNELS, &_audio_channel, NULL);
 350                 if (ret != FILEINFO_ERROR_NONE) {
 351                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 352                         SAFE_FREE(err_attr_name);
 353                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 354                 }
 355         }
 356
 357         *channel = _audio_channel;
 358
 359         return ret;
 360 }
 361
 362 static int __metadata_extractor_get_audio_samplerate(metadata_extractor_s *metadata, int *samplerate)
 363 {
 364         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 365         char *err_attr_name = NULL;
 366         int _audio_samplerate = 0;
 367
 368         if ((!metadata) || (!metadata->attr_h)) {
 369                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 370                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 371         }
 372
 373         if (metadata->audio_track_cnt > 0) {
 374                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &_audio_samplerate, NULL);
 375                 if (ret != FILEINFO_ERROR_NONE) {
 376                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 377                         SAFE_FREE(err_attr_name);
 378                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 379                 }
 380         }
 381
 382         *samplerate = _audio_samplerate;
 383
 384         return ret;
 385 }
 386
 387 static int __metadata_extractor_get_audio_bitpersample(metadata_extractor_s *metadata, int *bitpersample)
 388 {
 389         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 390         char *err_attr_name = NULL;
 391         int _audio_bit_per_sample = 0;
 392
 393         if ((!metadata) || (!metadata->attr_h)) {
 394                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 395                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 396         }
 397
 398         if (metadata->audio_track_cnt > 0) {
 399                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, &_audio_bit_per_sample, NULL);
 400                 if (ret != FILEINFO_ERROR_NONE) {
 401                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 402                         SAFE_FREE(err_attr_name);
 403                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 404                 }
 405         }
 406
 407         *bitpersample = _audio_bit_per_sample;
 408
 409         return ret;
 410 }
 411
 412 static int __metadata_extractor_get_audio_track_count(metadata_extractor_s *metadata, int *track_cnt)
 413 {
 414         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 415
 416         if (!metadata) {
 417                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 418                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 419         }
 420
 421         *track_cnt = metadata->audio_track_cnt;
 422
 423         return ret;
 424 }
 425
 426 static int __metadata_extractor_get_video_bitrate(metadata_extractor_s *metadata, int *bitrate)
 427 {
 428         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 429         char *err_attr_name = NULL;
 430         int _video_bitrate = 0;
 431
 432         if ((!metadata) || (!metadata->attr_h)) {
 433                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 434                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 435         }
 436
 437         if (metadata->video_track_cnt > 0) {
 438                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_BITRATE, &_video_bitrate, NULL);
 439                 if (ret != FILEINFO_ERROR_NONE) {
 440                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 441                         SAFE_FREE(err_attr_name);
 442                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 443                 }
 444         }
 445         *bitrate = _video_bitrate;
 446
 447         return ret;
 448 }
 449
 450 static int __metadata_extractor_get_video_FPS(metadata_extractor_s *metadata, int *fps)
 451 {
 452         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 453         char *err_attr_name = NULL;
 454         int _video_fps = 0;
 455
 456         if ((!metadata) || (!metadata->attr_h)) {
 457                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 458                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 459         }
 460
 461         if (metadata->video_track_cnt > 0) {
 462                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_FPS, &_video_fps, NULL);
 463                 if (ret != FILEINFO_ERROR_NONE) {
 464                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 465                         SAFE_FREE(err_attr_name);
 466                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 467                 }
 468         }
 469
 470         *fps = _video_fps;
 471
 472         return ret;
 473 }
 474
 475 static int __metadata_extractor_get_video_width(metadata_extractor_s *metadata, int *width)
 476 {
 477         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 478         char *err_attr_name = NULL;
 479         int _video_width = 0;
 480
 481         if ((!metadata) || (!metadata->attr_h)) {
 482                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 483                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 484         }
 485
 486         if (metadata->video_track_cnt > 0) {
 487                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_WIDTH, &_video_width, NULL);
 488                 if (ret != FILEINFO_ERROR_NONE) {
 489                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 490                         SAFE_FREE(err_attr_name);
 491                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 492                 }
 493         }
 494
 495         *width = _video_width;
 496
 497         return ret;
 498 }
 499
 500 static int __metadata_extractor_get_video_height(metadata_extractor_s *metadata, int *height)
 501 {
 502         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 503         char *err_attr_name = NULL;
 504         int _video_height = 0;
 505
 506         if ((!metadata) || (!metadata->attr_h)) {
 507                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 508                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 509         }
 510
 511         if (metadata->video_track_cnt > 0) {
 512                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_HEIGHT, &_video_height, NULL);
 513                 if (ret != FILEINFO_ERROR_NONE) {
 514                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 515                         SAFE_FREE(err_attr_name);
 516                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 517                 }
 518         }
 519
 520         *height = _video_height;
 521
 522         return ret;
 523 }
 524
 525 static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s *metadata, void **thumbnail, int *thumbnail_len)
 526 {
 527         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 528         char *err_attr_name = NULL;
 529         void *_video_thumbnail = NULL;
 530         int _video_thumbnail_len = 0;
 531
 532         if ((!metadata) || (!metadata->attr_h)) {
 533                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 534                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 535         }
 536
 537         if (metadata->video_track_cnt > 0) {
 538                 ret = mm_file_get_attrs(metadata->attr_h, &err_attr_name, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &_video_thumbnail, &_video_thumbnail_len, NULL);
 539                 if (ret != FILEINFO_ERROR_NONE) {
 540                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 541                         SAFE_FREE(err_attr_name);
 542                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 543                 }
 544         }
 545
 546         *thumbnail = _video_thumbnail;
 547         *thumbnail_len = _video_thumbnail_len;
 548
 549         return ret;
 550 }
 551
 552 static int __metadata_extractor_get_video_track_count(metadata_extractor_s *metadata, int *track_cnt)
 553 {
 554         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 555
 556         if (!metadata) {
 557                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
 558                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
 559         }
 560
 561         *track_cnt = metadata->video_track_cnt;
 562
 563         return ret;
 564 }
 565
 566 static int __metadata_extractor_get_artist(metadata_extractor_s *metadata, char **artist)
 567 {
 568         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 569         char *err_attr_name = NULL;
 570         char *_artist = NULL;
 571         int _tag_len = 0;
 572
 573         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTIST, &_artist, &_tag_len, NULL);
 574         if (ret != FILEINFO_ERROR_NONE) {
 575                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 576                 SAFE_FREE(err_attr_name);
 577                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 578         }
 579
 580         *artist = _artist;
 581
 582         return ret;
 583 }
 584
 585 static int __metadata_extractor_get_title(metadata_extractor_s *metadata, char **title)
 586 {
 587         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 588         char *err_attr_name = NULL;
 589         char *_title = NULL;
 590         int _tag_len = 0;
 591
 592         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_TITLE, &_title, &_tag_len, NULL);
 593         if (ret != FILEINFO_ERROR_NONE) {
 594                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 595                 SAFE_FREE(err_attr_name);
 596                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 597         }
 598
 599         *title = _title;
 600
 601         return ret;
 602 }
 603
 604 static int __metadata_extractor_get_album(metadata_extractor_s *metadata, char **album)
 605 {
 606         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 607         char *err_attr_name = NULL;
 608         char *_album = NULL;
 609         int _tag_len = 0;
 610
 611         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ALBUM, &_album, &_tag_len, NULL);
 612         if (ret != FILEINFO_ERROR_NONE) {
 613                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 614                 SAFE_FREE(err_attr_name);
 615                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 616         }
 617
 618         *album = _album;
 619
 620         return ret;
 621 }
 622
 623 static int __metadata_extractor_get_album_artist(metadata_extractor_s *metadata, char **album_artist)
 624 {
 625         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 626         char *err_attr_name = NULL;
 627         char *_album_artist = NULL;
 628         int _tag_len = 0;
 629
 630         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name, MM_FILE_TAG_ALBUM_ARTIST, &_album_artist, &_tag_len, NULL);
 631         if (ret != FILEINFO_ERROR_NONE) {
 632                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 633                 SAFE_FREE(err_attr_name);
 634                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 635         }
 636
 637         *album_artist = _album_artist;
 638
 639         return ret;
 640 }
 641
 642 static int __metadata_extractor_get_genre(metadata_extractor_s *metadata, char **genre)
 643 {
 644         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 645         char *err_attr_name = NULL;
 646         char *_genre = NULL;
 647         int _tag_len = 0;
 648
 649         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_GENRE, &_genre, &_tag_len, NULL);
 650         if (ret != FILEINFO_ERROR_NONE) {
 651                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 652                 SAFE_FREE(err_attr_name);
 653                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 654         }
 655
 656         *genre = _genre;
 657
 658         return ret;
 659 }
 660
 661 static int __metadata_extractor_get_author(metadata_extractor_s *metadata, char **author)
 662 {
 663         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 664         char *err_attr_name = NULL;
 665         char *_author = NULL;
 666         int _tag_len = 0;
 667
 668         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_AUTHOR, &_author, &_tag_len, NULL);
 669         if (ret != FILEINFO_ERROR_NONE) {
 670                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 671                 SAFE_FREE(err_attr_name);
 672                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 673         }
 674
 675         *author = _author;
 676
 677         return ret;
 678 }
 679
 680 static int __metadata_extractor_get_copyright(metadata_extractor_s *metadata, char **copyright)
 681 {
 682         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 683         char *err_attr_name = NULL;
 684         char *_copyright = NULL;
 685         int _tag_len = 0;
 686
 687         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_COPYRIGHT, &_copyright, &_tag_len, NULL);
 688         if (ret != FILEINFO_ERROR_NONE) {
 689                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 690                 SAFE_FREE(err_attr_name);
 691                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 692         }
 693
 694         *copyright = _copyright;
 695
 696         return ret;
 697 }
 698
 699 static int __metadata_extractor_get_date(metadata_extractor_s *metadata, char **date)
 700 {
 701         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 702         char *err_attr_name = NULL;
 703         char *_date = NULL;
 704         int _tag_len = 0;
 705
 706         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_DATE, &_date, &_tag_len, NULL);
 707         if (ret != FILEINFO_ERROR_NONE) {
 708                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 709                 SAFE_FREE(err_attr_name);
 710                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 711         }
 712
 713         *date = _date;
 714
 715         return ret;
 716 }
 717
 718 static int __metadata_extractor_get_description(metadata_extractor_s *metadata, char **description)
 719 {
 720         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 721         char *err_attr_name = NULL;
 722         char *_description = NULL;
 723         int _tag_len = 0;
 724
 725         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_DESCRIPTION, &_description, &_tag_len, NULL);
 726         if (ret != FILEINFO_ERROR_NONE) {
 727                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 728                 SAFE_FREE(err_attr_name);
 729                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 730         }
 731
 732         *description = _description;
 733
 734         return ret;
 735 }
 736
 737 static int __metadata_extractor_get_comment(metadata_extractor_s *metadata, char **comment)
 738 {
 739         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 740         char *err_attr_name = NULL;
 741         char *_comment = NULL;
 742         int _tag_len = 0;
 743
 744         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name, MM_FILE_TAG_COMMENT, &_comment, &_tag_len, NULL);
 745         if (ret != FILEINFO_ERROR_NONE) {
 746                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 747                 SAFE_FREE(err_attr_name);
 748                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 749         }
 750
 751         *comment = _comment;
 752
 753         return ret;
 754 }
 755
 756 static int __metadata_extractor_get_artwork(metadata_extractor_s *metadata, void **artwork, int *artwork_size)
 757 {
 758         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 759         char *err_attr_name = NULL;
 760         void *_artwork = NULL;
 761         int _artwork_size = 0;
 762         int _tag_len = 0;
 763
 764         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name, MM_FILE_TAG_ARTWORK_SIZE, &_artwork_size, NULL);
 765         if (ret != FILEINFO_ERROR_NONE) {
 766                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 767                 SAFE_FREE(err_attr_name);
 768                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 769         }
 770
 771         if (_artwork_size > 0) {
 772                 ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTWORK, &_artwork, &_tag_len, NULL);
 773                 if (ret != FILEINFO_ERROR_NONE) {
 774                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 775                         SAFE_FREE(err_attr_name);
 776                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 777                 }
 778         }
 779
 780         *artwork = _artwork;
 781         *artwork_size = _artwork_size;
 782
 783         return ret;
 784 }
 785
 786 static int __metadata_extractor_get_artwork_mime(metadata_extractor_s *metadata, char **artwork_mime)
 787 {
 788         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 789         char *err_attr_name = NULL;
 790         char *_artwork_mime = NULL;
 791         int _tag_len = 0;
 792
 793         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ARTWORK_MIME, &_artwork_mime, &_tag_len, NULL);
 794         if (ret != FILEINFO_ERROR_NONE) {
 795                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 796                 SAFE_FREE(err_attr_name);
 797                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 798         }
 799
 800         *artwork_mime = _artwork_mime;
 801
 802         return ret;
 803 }
 804
 805
 806 static int __metadata_extractor_get_track_num(metadata_extractor_s *metadata, char **track_num)
 807 {
 808         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 809         char *err_attr_name = NULL;
 810         char *_track_num = NULL;
 811         int _tag_len = 0;
 812
 813         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_TRACK_NUM, &_track_num, &_tag_len, NULL);
 814         if (ret != FILEINFO_ERROR_NONE) {
 815                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 816                 SAFE_FREE(err_attr_name);
 817                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 818         }
 819
 820         *track_num = _track_num;
 821
 822         return ret;
 823 }
 824
 825 static int __metadata_extractor_get_classification(metadata_extractor_s *metadata, char **classification)
 826 {
 827         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 828         char *err_attr_name = NULL;
 829         char *_classification = NULL;
 830         int _tag_len = 0;
 831
 832         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_CLASSIFICATION, &_classification, &_tag_len, NULL);
 833         if (ret != FILEINFO_ERROR_NONE) {
 834                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 835                 SAFE_FREE(err_attr_name);
 836                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 837         }
 838
 839         *classification = _classification;
 840
 841         return ret;
 842 }
 843
 844 static int __metadata_extractor_get_rating(metadata_extractor_s *metadata, char **rating)
 845 {
 846         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 847         char *err_attr_name = NULL;
 848         char *_rating = NULL;
 849         int _tag_len = 0;
 850
 851         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_RATING, &_rating, &_tag_len, NULL);
 852         if (ret != FILEINFO_ERROR_NONE) {
 853                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 854                 SAFE_FREE(err_attr_name);
 855                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 856         }
 857
 858         *rating = _rating;
 859
 860         return ret;
 861 }
 862
 863 static int __metadata_extractor_get_longitude(metadata_extractor_s *metadata, double *longitude)
 864 {
 865         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 866         char *err_attr_name = NULL;
 867         double _longitude = 0;
 868
 869         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_LONGITUDE, &_longitude, NULL);
 870         if (ret != FILEINFO_ERROR_NONE) {
 871                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 872                 SAFE_FREE(err_attr_name);
 873                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 874         }
 875
 876         *longitude = _longitude;
 877
 878         return ret;
 879 }
 880
 881 static int __metadata_extractor_get_latitude(metadata_extractor_s *metadata, double *latitude)
 882 {
 883         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 884         char *err_attr_name = NULL;
 885         double _latitude = 0;
 886
 887         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_LATIDUE, &_latitude, NULL);
 888         if (ret != FILEINFO_ERROR_NONE) {
 889                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 890                 SAFE_FREE(err_attr_name);
 891                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 892         }
 893
 894         *latitude = _latitude;
 895
 896         return ret;
 897 }
 898
 899 static int __metadata_extractor_get_altitude(metadata_extractor_s *metadata, double *altitude)
 900 {
 901         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 902         char *err_attr_name = NULL;
 903         double _altitude = 0;
 904
 905         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ALTIDUE, &_altitude, NULL);
 906         if (ret != FILEINFO_ERROR_NONE) {
 907                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 908                 SAFE_FREE(err_attr_name);
 909                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 910         }
 911
 912         *altitude = _altitude;
 913
 914         return ret;
 915 }
 916
 917 static int __metadata_extractor_get_conductor(metadata_extractor_s *metadata, char **conductor)
 918 {
 919         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 920         char *err_attr_name = NULL;
 921         char *_conductor = NULL;
 922         int _tag_len = 0;
 923
 924         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_CONDUCTOR, &_conductor, &_tag_len, NULL);
 925         if (ret != FILEINFO_ERROR_NONE) {
 926                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 927                 SAFE_FREE(err_attr_name);
 928                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 929         }
 930
 931         *conductor = _conductor;
 932
 933         return ret;
 934 }
 935 static int __metadata_extractor_get_unsynclyrics(metadata_extractor_s *metadata, char **unsynclyrics)
 936 {
 937         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 938         char *err_attr_name = NULL;
 939         char *_unsynclyrics = NULL;
 940         int _tag_len = 0;
 941
 942         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_UNSYNCLYRICS, &_unsynclyrics, &_tag_len, NULL);
 943         if (ret != FILEINFO_ERROR_NONE) {
 944                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 945                 SAFE_FREE(err_attr_name);
 946                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 947         }
 948
 949         *unsynclyrics = _unsynclyrics;
 950
 951         return ret;
 952 }
 953
 954 static int __metadata_extractor_get_recording_date(metadata_extractor_s *metadata, char **rec_date)
 955 {
 956         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 957         char *err_attr_name = NULL;
 958         char *_rec_date = NULL;
 959         int _tag_len = 0;
 960
 961         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_RECDATE, &_rec_date, &_tag_len, NULL);
 962         if (ret != FILEINFO_ERROR_NONE) {
 963                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 964                 SAFE_FREE(err_attr_name);
 965                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 966         }
 967
 968         *rec_date = _rec_date;
 969
 970         return ret;
 971 }
 972
 973 static int __metadata_extractor_get_rotate(metadata_extractor_s *metadata, char **rotate)
 974 {
 975         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 976         char *err_attr_name = NULL;
 977         char *_rotate = NULL;
 978         int _tag_len = 0;
 979
 980         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name,        MM_FILE_TAG_ROTATE, &_rotate, &_tag_len, NULL);
 981         if (ret != FILEINFO_ERROR_NONE) {
 982                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
 983                 SAFE_FREE(err_attr_name);
 984                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
 985         }
 986
 987         *rotate = _rotate;
 988
 989         return ret;
 990 }
 991
 992 static int __metadata_extractor_get_synclyrics_pair_num(metadata_extractor_s *metadata, int *synclyrics_num)
 993 {
 994         int ret = METADATA_EXTRACTOR_ERROR_NONE;
 995         char *err_attr_name = NULL;
 996         int _synclyrics_num = 0;
 997
 998         ret = mm_file_get_attrs(metadata->tag_h, &err_attr_name, MM_FILE_TAG_SYNCLYRICS_NUM, &_synclyrics_num, NULL);
 999         if (ret != FILEINFO_ERROR_NONE) {
1000                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
1001                 SAFE_FREE(err_attr_name);
1002                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
1003         }
1004
1005         *synclyrics_num = _synclyrics_num;
1006
1007         return ret;
1008 }
1009
1010 static int __metadata_extractor_destroy_handle(metadata_extractor_s *metadata)
1011 {
1012         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1013
1014         if (metadata->attr_h) {
1015                 ret = mm_file_destroy_content_attrs(metadata->attr_h);
1016                 if (ret != FILEINFO_ERROR_NONE) {
1017                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
1018                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
1019                 }
1020         }
1021
1022         if (metadata->tag_h) {
1023                 ret = mm_file_destroy_tag_attrs(metadata->tag_h);
1024                 if (ret != FILEINFO_ERROR_NONE) {
1025                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
1026                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
1027                 }
1028         }
1029
1030         return ret;
1031 }
1032
1033
1034 int metadata_extractor_create(metadata_extractor_h *metadata)
1035 {
1036         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1037
1038         if (metadata == NULL) {
1039                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1040                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1041         }
1042
1043         metadata_extractor_s *_metadata = (metadata_extractor_s *)calloc(1, sizeof(metadata_extractor_s));
1044         if (_metadata == NULL) {
1045                 metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1046                 return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1047         }
1048
1049         _metadata->path = NULL;
1050         _metadata->buffer = NULL;
1051         _metadata->buffer_size = 0;
1052         _metadata->audio_track_cnt = 0;
1053         _metadata->video_track_cnt = 0;
1054
1055         *metadata = (metadata_extractor_h)_metadata;
1056
1057         return ret;
1058 }
1059
1060 int metadata_extractor_set_path(metadata_extractor_h metadata, const char *path)
1061 {
1062         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1063         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1064
1065         if ((_metadata == NULL) || (path == NULL)) {
1066                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1067                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1068         }
1069
1070         /*check file path.. */
1071         if (g_file_test(path, G_FILE_TEST_IS_REGULAR)) {
1072                 metadata_extractor_sucure_info("path[%s] is exists.", path);
1073         } else {
1074                 metadata_extractor_sucure_info("path[%s] is not exists.", path);
1075                 return METADATA_EXTRACTOR_ERROR_FILE_EXISTS;
1076         }
1077
1078         if ((_metadata->path != NULL) || (_metadata->buffer != NULL)) {
1079                 __metadata_extractor_destroy_handle(_metadata);
1080                 SAFE_FREE(_metadata->path);
1081                 _metadata->attr_h = 0;
1082                 _metadata->tag_h = 0;
1083         }
1084
1085         _metadata->path = strdup(path);
1086         if (_metadata->path == NULL) {
1087                 metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1088                 return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1089         }
1090
1091         return ret;
1092 }
1093
1094 int metadata_extractor_set_buffer(metadata_extractor_h metadata, const void *buffer, int size)
1095 {
1096         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1097         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1098
1099         if ((_metadata == NULL) || (buffer == NULL) || (size <= 0)) {
1100                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1101                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1102         }
1103
1104         if ((_metadata->path != NULL) || (_metadata->buffer != NULL)) {
1105                 __metadata_extractor_destroy_handle(_metadata);
1106                 SAFE_FREE(_metadata->path);
1107                 _metadata->attr_h = 0;
1108                 _metadata->tag_h = 0;
1109         }
1110
1111         _metadata->buffer = (void *)buffer;
1112         _metadata->buffer_size = size;
1113
1114         return ret;
1115 }
1116
1117 int metadata_extractor_destroy(metadata_extractor_h metadata)
1118 {
1119         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1120         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1121
1122         if (!_metadata) {
1123                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1124                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1125         }
1126
1127         ret = __metadata_extractor_destroy_handle(_metadata);
1128
1129         SAFE_FREE(_metadata->path);
1130
1131         SAFE_FREE(_metadata);
1132
1133         return ret;
1134 }
1135
1136 int metadata_extractor_get_synclyrics(metadata_extractor_h metadata, int index, unsigned long *time_stamp, char **lyrics)
1137 {
1138         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1139         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1140         unsigned long _time_info = 0;
1141         char *_lyrics = NULL;
1142         int _synclyrics_num = 0;
1143
1144         if ((!_metadata) || ((!_metadata->path) && (!_metadata->buffer))) {
1145                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1146                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1147         }
1148
1149         ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_TAG);
1150         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1151                 return ret;
1152         }
1153
1154         ret = __metadata_extractor_get_synclyrics_pair_num(_metadata, &_synclyrics_num);
1155         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1156                 return ret;
1157         }
1158
1159         if ((_synclyrics_num > 0) && (index < _synclyrics_num)) {
1160                 ret = mm_file_get_synclyrics_info((MMHandleType)_metadata->tag_h, index, &_time_info, &_lyrics);
1161                 if (ret != FILEINFO_ERROR_NONE) {
1162                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
1163                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
1164                 }
1165                 if ((_lyrics != NULL) && (strlen(_lyrics) > 0)) {
1166                         *lyrics = strdup(_lyrics);
1167                         if (*lyrics == NULL) {
1168                                 metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1169                                 return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1170                         }
1171                 } else {
1172                         *lyrics = NULL;
1173                 }
1174
1175                 *time_stamp = _time_info;
1176         } else {
1177                 *lyrics = NULL;
1178                 *time_stamp = 0;
1179         }
1180
1181         return ret;
1182 }
1183
1184 int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extractor_attr_e attribute, char **value)
1185 {
1186         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1187         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1188         int i_value = 0;
1189         double d_value = 0;
1190         char *s_value = NULL;
1191         int is_string = 0;
1192         int is_double = 0;
1193
1194         if ((!_metadata) || ((!_metadata->path) && (!_metadata->buffer))) {
1195                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1196                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1197         }
1198
1199         if ((attribute == METADATA_HAS_VIDEO) || (attribute == METADATA_HAS_AUDIO)) {
1200                 if (_metadata->path != NULL)
1201                         ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_STREAM);
1202                 else
1203                         ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_ATTR);
1204         } else if ((attribute >= METADATA_DURATION) && (attribute < METADATA_HAS_AUDIO)) {
1205                 ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_ATTR);
1206         } else if ((attribute > METADATA_HAS_AUDIO) && (attribute <= METADATA_ROTATE)) {
1207                 ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_TAG);
1208         } else {
1209                 metadata_extractor_error("INVALID_PARAMETER [%d]", attribute);
1210                 ret = METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1211         }
1212
1213         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1214                 return ret;
1215         }
1216
1217         /*metadata_extractor_debug("attribute [%d]", attribute); */
1218
1219         switch (attribute) {
1220                 case METADATA_DURATION: {
1221                         is_string = 0;
1222                         ret = __metadata_extractor_get_duration(_metadata, &i_value);
1223                         break;
1224                 }
1225                 case METADATA_VIDEO_BITRATE: {
1226                         is_string = 0;
1227                         ret = __metadata_extractor_get_video_bitrate(_metadata, &i_value);
1228                         break;
1229                 }
1230                 case METADATA_VIDEO_FPS: {
1231                         is_string = 0;
1232                         ret = __metadata_extractor_get_video_FPS(_metadata, &i_value);
1233                         break;
1234                 }
1235                 case METADATA_VIDEO_WIDTH: {
1236                         is_string = 0;
1237                         ret = __metadata_extractor_get_video_width(_metadata, &i_value);
1238                         break;
1239                 }
1240                 case METADATA_VIDEO_HEIGHT: {
1241                         is_string = 0;
1242                         ret = __metadata_extractor_get_video_height(_metadata, &i_value);
1243                         break;
1244                 }
1245                 case METADATA_HAS_VIDEO: {
1246                         is_string = 0;
1247                         ret = __metadata_extractor_get_video_track_count(_metadata, &i_value);
1248                         break;
1249                 }
1250                 case METADATA_AUDIO_BITRATE: {
1251                         is_string = 0;
1252                         ret = __metadata_extractor_get_audio_bitrate(_metadata, &i_value);
1253                         break;
1254                 }
1255                 case METADATA_AUDIO_CHANNELS: {
1256                         is_string = 0;
1257                         ret = __metadata_extractor_get_audio_channel(_metadata, &i_value);
1258                         break;
1259                 }
1260                 case METADATA_AUDIO_SAMPLERATE: {
1261                         is_string = 0;
1262                         ret = __metadata_extractor_get_audio_samplerate(_metadata, &i_value);
1263                         break;
1264                 }
1265                 case METADATA_AUDIO_BITPERSAMPLE: {
1266                         is_string = 0;
1267                         ret = __metadata_extractor_get_audio_bitpersample(_metadata, &i_value);
1268                         break;
1269                 }
1270                 case METADATA_HAS_AUDIO: {
1271                         is_string = 0;
1272                         ret = __metadata_extractor_get_audio_track_count(_metadata, &i_value);
1273                         break;
1274                 }
1275                 case METADATA_ARTIST: {
1276                         is_string = 1;
1277                         ret = __metadata_extractor_get_artist(_metadata, &s_value);
1278                         break;
1279                 }
1280                 case METADATA_TITLE: {
1281                         is_string = 1;
1282                         ret = __metadata_extractor_get_title(_metadata, &s_value);
1283                         break;
1284                 }
1285                 case METADATA_ALBUM: {
1286                         is_string = 1;
1287                         ret = __metadata_extractor_get_album(_metadata, &s_value);
1288                         break;
1289                 }
1290                 case METADATA_ALBUM_ARTIST: {
1291                         is_string = 1;
1292                         ret = __metadata_extractor_get_album_artist(_metadata, &s_value);
1293                         break;
1294                 }
1295                 case METADATA_GENRE: {
1296                         is_string = 1;
1297                         ret = __metadata_extractor_get_genre(_metadata, &s_value);
1298                         break;
1299                 }
1300                 case METADATA_AUTHOR: {
1301                         is_string = 1;
1302                         ret = __metadata_extractor_get_author(_metadata, &s_value);
1303                         break;
1304                 }
1305                 case METADATA_COPYRIGHT: {
1306                         is_string = 1;
1307                         ret = __metadata_extractor_get_copyright(_metadata, &s_value);
1308                         break;
1309                 }
1310                 case METADATA_DATE: {
1311                         is_string = 1;
1312                         ret = __metadata_extractor_get_date(_metadata, &s_value);
1313                         break;
1314                 }
1315                 case METADATA_DESCRIPTION: {
1316                         is_string = 1;
1317                         ret = __metadata_extractor_get_description(_metadata, &s_value);
1318                         break;
1319                 }
1320                 case METADATA_COMMENT: {
1321                         is_string = 1;
1322                         ret = __metadata_extractor_get_comment(_metadata, &s_value);
1323                         break;
1324                 }
1325                 case METADATA_TRACK_NUM: {
1326                         is_string = 1;
1327                         ret = __metadata_extractor_get_track_num(_metadata, &s_value);
1328                         break;
1329                 }
1330                 case METADATA_CLASSIFICATION: {
1331                         is_string = 1;
1332                         ret = __metadata_extractor_get_classification(_metadata, &s_value);
1333                         break;
1334                 }
1335                 case METADATA_RATING: {
1336                         is_string = 1;
1337                         ret = __metadata_extractor_get_rating(_metadata, &s_value);
1338                         break;
1339                 }
1340                 case METADATA_LONGITUDE: {
1341                         is_double = 1;
1342                         ret = __metadata_extractor_get_longitude(_metadata, &d_value);
1343                         break;
1344                 }
1345                 case METADATA_LATITUDE: {
1346                         is_double = 1;
1347                         ret = __metadata_extractor_get_latitude(_metadata, &d_value);
1348                         break;
1349                 }
1350                 case METADATA_ALTITUDE: {
1351                         is_double = 1;
1352                         ret = __metadata_extractor_get_altitude(_metadata, &d_value);
1353                         break;
1354                 }
1355                 case METADATA_CONDUCTOR: {
1356                         is_string = 1;
1357                         ret = __metadata_extractor_get_conductor(_metadata, &s_value);
1358                         break;
1359                 }
1360                 case METADATA_UNSYNCLYRICS: {
1361                         is_string = 1;
1362                         ret = __metadata_extractor_get_unsynclyrics(_metadata, &s_value);
1363                         break;
1364                 }
1365                 case METADATA_SYNCLYRICS_NUM: {
1366                         is_string = 0;
1367                         ret = __metadata_extractor_get_synclyrics_pair_num(_metadata, &i_value);
1368                         break;
1369                 }
1370                 case METADATA_RECDATE: {
1371                         is_string = 1;
1372                         ret = __metadata_extractor_get_recording_date(_metadata, &s_value);
1373                         break;
1374                 }
1375                 case METADATA_ROTATE: {
1376                         is_string = 1;
1377                         ret = __metadata_extractor_get_rotate(_metadata, &s_value);
1378                         break;
1379                 }
1380                 default :
1381                         break;
1382         }
1383
1384         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1385                 *value = NULL;
1386                 return ret;
1387         }
1388
1389         if (is_string) {
1390                 if ((s_value != NULL) && (strlen(s_value) > 0)) {
1391                         *value = strdup(s_value);
1392                         if (*value == NULL) {
1393                                 metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1394                                 return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1395                         }
1396                 } else {
1397                         *value = NULL;
1398                 }
1399         } else {
1400                 char extracted_metadata[META_MAX_LEN] = {0, };
1401
1402                 if (is_double) {
1403                         snprintf(extracted_metadata, sizeof(extracted_metadata), "%f", d_value);
1404                 } else {
1405                         snprintf(extracted_metadata, sizeof(extracted_metadata), "%d", i_value);
1406                 }
1407
1408                 *value = strdup(extracted_metadata);
1409                 if (*value == NULL) {
1410                         metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1411                         return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1412                 }
1413         }
1414
1415         return ret;
1416 }
1417
1418 int metadata_extractor_get_artwork(metadata_extractor_h metadata, void **artwork, int *size, char **mime_type)
1419 {
1420         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1421         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1422         void *_artwork = NULL;
1423         int _artwork_size = 0;
1424         char *_artwork_mime = NULL;
1425
1426         if ((!_metadata) || ((!_metadata->path) && (!_metadata->buffer))) {
1427                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1428                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1429         }
1430
1431         ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_TAG);
1432         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1433                 return ret;
1434         }
1435
1436         ret = __metadata_extractor_get_artwork(_metadata, &_artwork, &_artwork_size);
1437         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1438                 return ret;
1439         }
1440
1441         if ((_artwork_size > 0) && (_artwork != NULL)) {
1442                 ret = __metadata_extractor_get_artwork_mime(_metadata, &_artwork_mime);
1443                 if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1444                         *artwork = NULL;
1445                         *size = 0;
1446
1447                         return ret;
1448                 }
1449
1450                 *artwork = calloc(1, _artwork_size);
1451                 if (*artwork != NULL) {
1452                         memcpy(*artwork, _artwork, _artwork_size);
1453                         *size = _artwork_size;
1454                 } else {
1455                         *size = 0;
1456                 }
1457
1458                 if ((_artwork_mime != NULL) && (strlen(_artwork_mime) > 0)) {
1459                         *mime_type = strdup(_artwork_mime);
1460                         if (*mime_type == NULL) {
1461                                 metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1462                                 return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1463                         }
1464                 } else {
1465                         *mime_type = NULL;
1466                 }
1467
1468         } else {
1469                 *artwork = NULL;
1470                 *mime_type = NULL;
1471                 *size = 0;
1472         }
1473
1474         return ret;
1475 }
1476
1477 int metadata_extractor_get_frame(metadata_extractor_h metadata, void **frame, int *size)
1478 {
1479         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1480         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1481         void *_frame = NULL;
1482         int _frame_size = 0;
1483
1484         if ((!_metadata) || ((!_metadata->path) && (!_metadata->buffer)) || (!size)) {
1485                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1486                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1487         }
1488
1489         ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_ATTR);
1490         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1491                 return ret;
1492         }
1493
1494         ret = __metadata_extractor_get_video_thumbnail(_metadata, &_frame, &_frame_size);
1495         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1496                 return ret;
1497         }
1498
1499         if ((_frame_size > 0) && (_frame != NULL)) {
1500                 *frame = calloc(1, _frame_size);
1501                 if (*frame == NULL) {
1502                         metadata_extractor_error("OUT_OF_MEMORY(0x%08x)", METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY);
1503                         return METADATA_EXTRACTOR_ERROR_OUT_OF_MEMORY;
1504                 }
1505                 memcpy(*frame, _frame, _frame_size);
1506                 *size = _frame_size;
1507         } else {
1508                 *frame = NULL;
1509                 *size = 0;
1510         }
1511
1512         return ret;
1513 }
1514
1515 int metadata_extractor_get_frame_at_time(metadata_extractor_h metadata, unsigned long timestamp, bool is_accurate, void **frame, int *size)
1516 {
1517         int ret = METADATA_EXTRACTOR_ERROR_NONE;
1518         metadata_extractor_s *_metadata = (metadata_extractor_s *)metadata;
1519         void *_frame = NULL;
1520         int _frame_size = 0;
1521         int width = 0;
1522         int height = 0;
1523         long long micro_timestamp = 0;
1524
1525         if ((!_metadata) || ((!_metadata->path) && (!_metadata->buffer)) || (!size)) {
1526                 metadata_extractor_error("INVALID_PARAMETER(0x%08x)", METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER);
1527                 return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
1528         }
1529
1530         micro_timestamp = (long long)timestamp * 1000;
1531
1532         metadata_extractor_debug("accurate [%d] timestamp[%d] micro_timestamp[%lld]", is_accurate, timestamp, micro_timestamp);
1533
1534         if (_metadata->path) {
1535                 ret = mm_file_get_video_frame(_metadata->path, micro_timestamp, is_accurate, (unsigned char **)&_frame, &_frame_size, &width, &height);
1536         } else {
1537                 ret = mm_file_get_video_frame_from_memory(_metadata->buffer, _metadata->buffer_size, micro_timestamp, is_accurate, (unsigned char **)&_frame, &_frame_size, &width, &height);
1538         }
1539
1540         if (ret != FILEINFO_ERROR_NONE) {
1541                 SAFE_FREE(_frame);
1542                 metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED(0x%08x)", ret);
1543                 return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
1544         }
1545
1546         if (_frame != NULL) {
1547                 if ((_frame_size > 0)) {
1548                         *frame = _frame;
1549                         *size = _frame_size;
1550                 } else {
1551                         SAFE_FREE(_frame);
1552                         metadata_extractor_error("METADATA_EXTRACTOR_ERROR_OPERATION_FAILED (0x%08x)", METADATA_EXTRACTOR_ERROR_OPERATION_FAILED);
1553                         return METADATA_EXTRACTOR_ERROR_OPERATION_FAILED;
1554                 }
1555         } else {
1556                 *frame = NULL;
1557                 *size = 0;
1558         }
1559
1560         return ret;
1561 }