tests/mm_file_test.c

   1 /*
   2  * libmm-fileinfo
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stdbool.h>
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <sys/time.h>
  30 #include <unistd.h>
  31
  32 #include <mm_file.h>
  33 #include "mm_file_traverse.h"
  34 #include "mm_file_debug.h"
  35
  36 #define MM_TIME_CHECK_START \
  37         { FILE *msg_tmp_fp = fopen("time_check.txt", "a+"); struct timeval start, finish; gettimeofday(&start, NULL);
  38 #define MM_TIME_CHECK_FINISH(title) \
  39         gettimeofday(&finish, NULL); \
  40         double end_time = (finish.tv_sec + 1e-6*finish.tv_usec); \
  41         double start_time = (start.tv_sec + 1e-6*start.tv_usec); \
  42         if (msg_tmp_fp != NULL) { \
  43                 fprintf(msg_tmp_fp, "%s\n", title); \
  44                 fprintf(msg_tmp_fp, " - start_time:   %3.5lf sec\n", start_time); \
  45                 fprintf(msg_tmp_fp, " - finish_time:  %3.5lf sec\n", end_time); \
  46                 fprintf(msg_tmp_fp, " - elapsed time: %3.5lf sec\n", end_time - start_time); \
  47                 fflush(msg_tmp_fp); fclose(msg_tmp_fp); } }
  48
  49 #define SAFE_FREE(src)                  { if (src) {free(src); src = NULL; } }
  50
  51 typedef struct _mmfile_value {
  52         int len;
  53         union {
  54                 int i_val;
  55                 double d_val;
  56                 char *s_val;
  57                 void *p_val;
  58         } value;
  59 } mmfile_value_t;
  60
  61 typedef struct _TagContext {
  62         mmfile_value_t artist;
  63         mmfile_value_t title;
  64         mmfile_value_t album;
  65         mmfile_value_t album_artist;
  66         mmfile_value_t genre;
  67         mmfile_value_t author;
  68         mmfile_value_t copyright;
  69         mmfile_value_t date;                    /*string */
  70         mmfile_value_t recdate;                 /*string */
  71         mmfile_value_t part_of_set;                     /*string */
  72         mmfile_value_t description;
  73         mmfile_value_t comment;
  74         mmfile_value_t artwork;         /*data */
  75         mmfile_value_t artwork_size;    /*int */
  76         mmfile_value_t artwork_mime;
  77         mmfile_value_t track_num;
  78         mmfile_value_t classfication;
  79         mmfile_value_t rating;
  80         mmfile_value_t conductor;
  81         mmfile_value_t longitude;               /*-> double */
  82         mmfile_value_t latitude;
  83         mmfile_value_t altitude;                /*<-double */
  84         mmfile_value_t unsynclyrics;
  85         mmfile_value_t synclyrics_size;
  86         mmfile_value_t rotate;                  /*string */
  87         mmfile_value_t is_spherical;
  88         mmfile_value_t is_stitched;
  89         mmfile_value_t stitching_software;      /*string */
  90         mmfile_value_t projection_type;         /*string */
  91         mmfile_value_t stereo_mode;                     /*string */
  92         mmfile_value_t source_count;
  93         mmfile_value_t init_view_heading;
  94         mmfile_value_t init_view_pitch;
  95         mmfile_value_t init_view_roll;
  96         mmfile_value_t timestamp;
  97         mmfile_value_t full_pano_width;
  98         mmfile_value_t full_pano_height;
  99         mmfile_value_t cropped_area_image_width;
 100         mmfile_value_t cropped_area_image_height;
 101         mmfile_value_t cropped_area_left;
 102         mmfile_value_t cropped_area_top;
 103         mmfile_value_t ambisonic_type;
 104         mmfile_value_t ambisonic_format;
 105         mmfile_value_t ambisonic_order;
 106         mmfile_value_t stereo_mode_v2;
 107         mmfile_value_t proj_type_v2;
 108         mmfile_value_t metadata_source_v2;      /*string */
 109         mmfile_value_t pose_yaw_degrees_v2;
 110         mmfile_value_t pose_pitch_degrees_v2;
 111         mmfile_value_t pose_roll_degrees_v2;
 112         mmfile_value_t cbmp_layout_v2;
 113         mmfile_value_t cbmp_padding_v2;
 114         mmfile_value_t equi_projection_bounds_top_v2;
 115         mmfile_value_t equi_projection_bounds_bottom_v2;
 116         mmfile_value_t equi_projection_bounds_left_v2;
 117         mmfile_value_t equi_projection_bounds_right_v2;
 118         mmfile_value_t smta;
 119 } TagContext_t;
 120
 121 typedef struct _ContentContext {
 122         int duration;
 123         int video_codec;
 124         int video_bitrate;
 125         int video_fps;
 126         int video_w;
 127         int video_h;
 128         int video_track_id;
 129         int video_track_num;
 130         int audio_codec;
 131         int audio_bitrate;
 132         int audio_channel;
 133         int audio_samplerate;
 134         int audio_track_id;
 135         int audio_track_num;
 136         int audio_bitpersample;
 137         mmfile_value_t thumbnail;
 138 } ContentContext_t;
 139
 140
 141 const char *AudioCodecTypeString[] = {
 142         "AMR", "G723.1", "MP3", "OGG", "AAC", "WMA", "MMF", "ADPCM", "WAVE", "WAVE NEW",        /* 0~9 */
 143         "MIDI", "IMELODY", "MXMF", "MPEG1-Layer1 codec", "MPEG1-Layer2 codec",  /* 10~14 */
 144         "G711", "G722", "G722.1", "G722.2  (AMR-WB)", "G723 wideband speech",   /* 15~19 */
 145         "G726 (ADPCM)", "G728 speech", "G729", "G729a", "G729.1",       /* 20~24 */
 146         "Real", "AAC-Low complexity", "AAC-Main profile", "AAC-Scalable sample rate", "AAC-Long term prediction",       /* 25~29 */
 147         "AAC-High Efficiency v1", "AAC-High efficiency v2",     "DolbyDigital", "Apple Lossless", "Sony proprietary",   /* 30~34 */
 148         "SPEEX", "Vorbis", "AIFF", "AU", "None (will be deprecated)",   /*35~39 */
 149         "PCM", "ALAW", "MULAW", "MS ADPCM", "FLAC"      /* 40~44 */
 150 };
 151
 152
 153 const char *VideoCodecTypeString[] = {
 154         "None (will be deprecated)",    /* 0 */
 155         "H263", "H264", "H26L", "MPEG4", "MPEG1",       /* 1~5 */
 156         "WMV", "DIVX", "XVID", "H261", "H262/MPEG2-part2",      /* 6~10 */
 157         "H263v2", "H263v3", "Motion JPEG", "MPEG2", "MPEG4 part-2 Simple profile",      /* 11~15 */
 158         "MPEG4 part-2 Advanced Simple profile", "MPEG4 part-2 Main profile", "MPEG4 part-2 Core profile", "MPEG4 part-2 Adv Coding Eff profile", "MPEG4 part-2 Adv RealTime Simple profile",    /* 16~20 */
 159         "MPEG4 part-10 (h.264)", "Real", "VC-1", "AVS", "Cinepak",      /* 21~25 */
 160         "Indeo", "Theora", "Flv"        /* 26~28 */
 161 };
 162
 163
 164
 165 FILE *fpFailList = NULL;
 166
 167 static int mmfile_get_file_infomation(void *data, void *user_data, bool file_test);
 168 static int mmfile_get_video_frame(void *data, void *accurate, bool file_test);
 169
 170
 171 inline static int mm_file_is_little_endian(void)
 172 {
 173         int i = 0x00000001;
 174         return ((char *)&i)[0];
 175 }
 176
 177 #define READ_FROM_FILE(FILE_PATH, data, size) \
 178         do {    \
 179                 FILE *fp = fopen(FILE_PATH, "r");       \
 180                 long lsize = 0; \
 181                 if (fp) {       \
 182                         if (fseek(fp, 0, SEEK_END) < 0) { printf("fseek failed\n"); fclose(fp); break; }        \
 183                         lsize = ftell(fp);      \
 184                         if (lsize <= 0) { printf("ftell failed\n"); fclose(fp); break; }        \
 185                         if (fseek(fp, 0, SEEK_SET) < 0) { printf("fseek failed\n"); fclose(fp); break; }        \
 186                         data = malloc(lsize);   \
 187                         if (!data) { printf("ftell failed\n"); fclose(fp); break; }     \
 188                         if (fread(data, sizeof(char), lsize, fp) != (size_t)lsize) { printf("fread error\n"); SAFE_FREE(data); fclose(fp); break; }     \
 189                         fclose(fp);     \
 190                         size = (unsigned int)lsize; \
 191                         printf("file size = %d\n", size);       \
 192                 }       \
 193         } while (0)
 194
 195 static int
 196 _is_file_exist(const char *filename)
 197 {
 198         int ret = 1;
 199         if (filename) {
 200                 const char *to_access = (strstr(filename, "file://") != NULL) ? filename + 7 : filename;
 201                 ret = access(to_access, R_OK);
 202                 if (ret != 0) {
 203                         printf("file [%s] not found.\n", to_access);
 204                 }
 205         }
 206         return !ret;
 207 }
 208
 209
 210 int main(int argc, char **argv)
 211 {
 212         struct stat statbuf;
 213         bool file_test = true;          /*if you want to test mm_file_create_content_XXX_from_memory() set file_test to false */
 214
 215         if (_is_file_exist(argv[1])) {
 216                 int ret = lstat(argv[1], &statbuf);
 217                 if (ret < 0) {
 218                         printf("lstat error[%d]\n", ret);
 219                         return MMFILE_FAIL;
 220                 }
 221
 222                 if (fpFailList == NULL) {
 223                         fpFailList = fopen("/opt/var/log/mmfile_fails.txt", "w");
 224                 }
 225
 226                 if (S_ISDIR(statbuf.st_mode))   {
 227                         mmfile_get_file_names(argv[1], mmfile_get_file_infomation, NULL);
 228                 } else {
 229                         if (argv[2] == NULL)
 230                                 mmfile_get_file_infomation(argv[1], NULL, file_test);
 231                         else
 232                                 mmfile_get_video_frame(argv[1], argv[2], file_test);
 233                 }
 234
 235                 if (fpFailList != NULL) {
 236                         fflush(fpFailList);
 237                         fclose(fpFailList);
 238                 }
 239         }
 240
 241         return 0;/*exit(0); */
 242 }
 243
 244 static int mmfile_get_file_infomation(void *data, void *user_data, bool file_test)
 245 {
 246         MMHandleType content_attrs = 0;
 247         MMHandleType tag_attrs = 0;
 248         int audio_track_num = 0;
 249         int video_track_num = 0;
 250         int ret = 0;
 251         char filename[512] = {0, };
 252
 253         memset(filename, 0x00, sizeof(filename));
 254         SAFE_STRLCPY(filename, (char *)data, sizeof(filename));
 255
 256         MM_TIME_CHECK_START
 257
 258         printf("Extracting information for [%s] \n", filename);
 259         /* get track info */
 260         ret = mm_file_get_stream_info(filename, &audio_track_num, &video_track_num);
 261         if (ret == FILEINFO_ERROR_NONE) {
 262                 printf("# audio=%d, video=%d\n", audio_track_num, video_track_num);
 263         } else {
 264                 printf("Failed to mm_file_get_stream_info() error=[%x]\n", ret);
 265         }
 266
 267         if (file_test) {
 268                 /* get content handle */
 269                 ret = mm_file_create_content_attrs(&content_attrs, filename);
 270         } else {
 271                 unsigned int file_size = 0;
 272                 unsigned char *buffer = NULL;
 273                 /* Read file */
 274                 READ_FROM_FILE(filename, buffer, file_size);
 275
 276                 ret = mm_file_create_content_attrs_from_memory(&content_attrs, buffer, file_size, MM_FILE_FORMAT_3GP);
 277                 SAFE_FREE(buffer);
 278         }
 279
 280         if (ret == FILEINFO_ERROR_NONE && content_attrs) {
 281                 ContentContext_t ccontent;
 282                 memset(&ccontent, 0, sizeof(ContentContext_t));
 283
 284                 ret = mm_file_get_attrs(content_attrs, MM_FILE_CONTENT_DURATION, &ccontent.duration, NULL);
 285                 printf("# duration: %d\n", ccontent.duration);
 286
 287                 if (ret != FILEINFO_ERROR_NONE)
 288                         printf("failed to get attrs\n");
 289
 290                 if (audio_track_num) {
 291                         ret = mm_file_get_attrs(content_attrs,
 292                                                                 MM_FILE_CONTENT_AUDIO_CODEC, &ccontent.audio_codec,
 293                                                                 MM_FILE_CONTENT_AUDIO_SAMPLERATE, &ccontent.audio_samplerate,
 294                                                                 MM_FILE_CONTENT_AUDIO_BITRATE, &ccontent.audio_bitrate,
 295                                                                 MM_FILE_CONTENT_AUDIO_CHANNELS, &ccontent.audio_channel,
 296                                                                 MM_FILE_CONTENT_AUDIO_TRACK_INDEX, &ccontent.audio_track_id,
 297                                                                 MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &ccontent.audio_track_num,
 298                                                                 MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, &ccontent.audio_bitpersample,
 299                                                                 NULL);
 300
 301                         if (ret != FILEINFO_ERROR_NONE) {
 302                                 printf("failed to get audio attrs\n");
 303                         } else {
 304                                 printf("[Audio] ----------------------------------------- \n");
 305                                 printf("# audio codec: %d ", ccontent.audio_codec);
 306                                 printf("[%s]\n", (ccontent.audio_codec >= 0 && ccontent.audio_codec < MM_AUDIO_CODEC_NUM) ? AudioCodecTypeString[ccontent.audio_codec] : "Invalid");
 307                                 printf("# audio samplerate: %d Hz\n", ccontent.audio_samplerate);
 308                                 printf("# audio bitrate: %d bps\n", ccontent.audio_bitrate);
 309                                 printf("# audio channel: %d\n", ccontent.audio_channel);
 310                                 printf("# audio track id: %d\n", ccontent.audio_track_id);
 311                                 printf("# audio track num: %d\n", ccontent.audio_track_num);
 312                                 printf("# audio bit per sample: %d\n", ccontent.audio_bitpersample);
 313                         }
 314                 }
 315
 316                 if (video_track_num) {
 317                         ret = mm_file_get_attrs(content_attrs,
 318                                                                 MM_FILE_CONTENT_VIDEO_CODEC, &ccontent.video_codec,
 319                                                                 MM_FILE_CONTENT_VIDEO_BITRATE, &ccontent.video_bitrate,
 320                                                                 MM_FILE_CONTENT_VIDEO_FPS, &ccontent.video_fps,
 321                                                                 MM_FILE_CONTENT_VIDEO_TRACK_INDEX, &ccontent.video_track_id,
 322                                                                 MM_FILE_CONTENT_VIDEO_WIDTH, &ccontent.video_w,
 323                                                                 MM_FILE_CONTENT_VIDEO_HEIGHT, &ccontent.video_h,
 324                                                                 MM_FILE_CONTENT_VIDEO_THUMBNAIL, &ccontent.thumbnail.value.p_val, &ccontent.thumbnail.len,
 325                                                                 NULL);
 326
 327                         if (ret != FILEINFO_ERROR_NONE) {
 328                                 printf("failed to get video attrs\n");
 329                         } else {
 330                                 printf("[Video] ----------------------------------------- \n");
 331                                 printf("# video codec: %d ", ccontent.video_codec);
 332                                 printf("[%s]\n", (ccontent.video_codec >= 0 && ccontent.video_codec < MM_VIDEO_CODEC_NUM) ? VideoCodecTypeString[ccontent.video_codec] : "Invalid");
 333                                 printf("# video bitrate: %d bps\n", ccontent.video_bitrate);
 334                                 printf("# video fps: %d\n", ccontent.video_fps);
 335                                 printf("# video track id: %d\n", ccontent.video_track_id);
 336                                 printf("# video width/height: %d x %d\n", ccontent.video_w, ccontent.video_h);
 337                                 printf("# video thumbnail: %p\n", ccontent.thumbnail.value.p_val);
 338                         }
 339                 }
 340
 341                 mm_file_destroy_content_attrs(content_attrs);
 342         } else {
 343                 printf("Failed to mm_file_create_content_attrs() error=[%x]\n", ret);
 344         }
 345
 346         if (file_test) {
 347                 /* get tag handle */
 348                 ret = mm_file_create_tag_attrs(&tag_attrs, filename);
 349         } else {
 350                 unsigned int file_size = 0;
 351                 unsigned char *buffer = NULL;
 352                 /* Read file */
 353                 READ_FROM_FILE(filename, buffer, file_size);
 354
 355                 ret = mm_file_create_tag_attrs_from_memory(&tag_attrs, buffer, file_size, MM_FILE_FORMAT_3GP);
 356                 SAFE_FREE(buffer);
 357         }
 358
 359         if (ret == FILEINFO_ERROR_NONE && tag_attrs) {
 360                 TagContext_t ctag;
 361                 memset(&ctag, 0, sizeof(TagContext_t));
 362                 /* get attributes of tag  */
 363                 ret = mm_file_get_attrs(tag_attrs,
 364                                                 MM_FILE_TAG_ARTIST, &ctag.artist.value.s_val, &ctag.artist.len,
 365                                                 MM_FILE_TAG_ALBUM, &ctag.album.value.s_val, &ctag.album.len,
 366                                                 MM_FILE_TAG_ALBUM_ARTIST, &ctag.album_artist.value.s_val, &ctag.album_artist.len,
 367                                                 MM_FILE_TAG_TITLE, &ctag.title.value.s_val, &ctag.title.len,
 368                                                 MM_FILE_TAG_GENRE, &ctag.genre.value.s_val, &ctag.genre.len,
 369                                                 MM_FILE_TAG_AUTHOR, &ctag.author.value.s_val, &ctag.author.len,
 370                                                 MM_FILE_TAG_COPYRIGHT, &ctag.copyright.value.s_val, &ctag.copyright.len,
 371                                                 MM_FILE_TAG_DATE, &ctag.date.value.s_val, &ctag.date.len,
 372                                                 MM_FILE_TAG_RECDATE, &ctag.recdate.value.s_val, &ctag.recdate.len,
 373                                                 MM_FILE_TAG_POS, &ctag.part_of_set.value.s_val, &ctag.part_of_set.len,
 374                                                 MM_FILE_TAG_DESCRIPTION, &ctag.description.value.s_val, &ctag.description.len,
 375                                                 MM_FILE_TAG_COMMENT, &ctag.comment.value.s_val, &ctag.comment.len,
 376                                                 MM_FILE_TAG_ARTWORK, &ctag.artwork.value.p_val, &ctag.artwork.len,
 377                                                 MM_FILE_TAG_ARTWORK_SIZE, &ctag.artwork_size.value.i_val,
 378                                                 MM_FILE_TAG_ARTWORK_MIME, &ctag.artwork_mime.value.s_val, &ctag.artwork_mime.len,
 379                                                 MM_FILE_TAG_TRACK_NUM, &ctag.track_num.value.s_val, &ctag.track_num.len,
 380                                                 MM_FILE_TAG_CLASSIFICATION, &ctag.classfication.value.s_val, &ctag.classfication.len,
 381                                                 MM_FILE_TAG_RATING, &ctag.rating.value.s_val, &ctag.rating.len,
 382                                                 MM_FILE_TAG_LONGITUDE, &ctag.longitude.value.d_val,
 383                                                 MM_FILE_TAG_LATIDUE, &ctag.latitude.value.d_val,
 384                                                 MM_FILE_TAG_ALTIDUE, &ctag.altitude.value.d_val,
 385                                                 MM_FILE_TAG_CONDUCTOR, &ctag.conductor.value.s_val, &ctag.conductor.len,
 386                                                 MM_FILE_TAG_UNSYNCLYRICS, &ctag.unsynclyrics.value.s_val, &ctag.unsynclyrics.len,
 387                                                 MM_FILE_TAG_SYNCLYRICS_NUM, &ctag.synclyrics_size.value.i_val,
 388                                                 MM_FILE_TAG_ROTATE, &ctag.rotate.value.s_val, &ctag.rotate.len,
 389                                                 MM_FILE_TAG_SPHERICAL, &ctag.is_spherical.value.i_val,
 390                                                 MM_FILE_TAG_SPHERICAL_STITCHED, &ctag.is_stitched.value.i_val,
 391                                                 MM_FILE_TAG_SPHERICAL_STITCHING_SOFTWARE, &ctag.stitching_software.value.s_val, &ctag.stitching_software.len,
 392                                                 MM_FILE_TAG_SPHERICAL_PROJECTION_TYPE, &ctag.projection_type.value.s_val, &ctag.projection_type.len,
 393                                                 MM_FILE_TAG_SPHERICAL_STEREO_MODE, &ctag.stereo_mode.value.s_val, &ctag.stereo_mode.len,
 394                                                 MM_FILE_TAG_SPHERICAL_SOURCE_COUNT, &ctag.source_count.value.i_val,
 395                                                 MM_FILE_TAG_SPHERICAL_INIT_VIEW_HEADING, &ctag.init_view_heading.value.i_val,
 396                                                 MM_FILE_TAG_SPHERICAL_INIT_VIEW_PITCH, &ctag.init_view_pitch.value.i_val,
 397                                                 MM_FILE_TAG_SPHERICAL_INIT_VIEW_ROLL, &ctag.init_view_roll.value.i_val,
 398                                                 MM_FILE_TAG_SPHERICAL_TIMESTAMP, &ctag.timestamp.value.i_val,
 399                                                 MM_FILE_TAG_SPHERICAL_FULL_PANO_WIDTH, &ctag.full_pano_width.value.i_val,
 400                                                 MM_FILE_TAG_SPHERICAL_FULL_PANO_HEIGHT, &ctag.full_pano_height.value.i_val,
 401                                                 MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_WIDTH, &ctag.cropped_area_image_width.value.i_val,
 402                                                 MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_HEIGHT, &ctag.cropped_area_image_height.value.i_val,
 403                                                 MM_FILE_TAG_SPHERICAL_CROPPED_AREA_LEFT, &ctag.cropped_area_left.value.i_val,
 404                                                 MM_FILE_TAG_SPHERICAL_CROPPED_AREA_TOP, &ctag.cropped_area_top.value.i_val,
 405                                                 MM_FILE_TAG_AMBISONIC_TYPE, &ctag.ambisonic_type.value.i_val,
 406                                                 MM_FILE_TAG_AMBISONIC_FORMAT, &ctag.ambisonic_format.value.i_val,
 407                                                 MM_FILE_TAG_AMBISONIC_ORDER, &ctag.ambisonic_order.value.i_val,
 408                                                 MM_FILE_TAG_SPHERICAL_V2_STEREO_MODE, &ctag.stereo_mode_v2.value.i_val,
 409                                                 MM_FILE_TAG_SPHERICAL_V2_METADATA_SOURCE, &ctag.metadata_source_v2.value.s_val, &ctag.metadata_source_v2.len,
 410                                                 MM_FILE_TAG_SPHERICAL_V2_PROJ_TYPE, &ctag.proj_type_v2.value.i_val,
 411                                                 MM_FILE_TAG_SPHERICAL_V2_POSE_YAW, &ctag.pose_yaw_degrees_v2.value.i_val,
 412                                                 MM_FILE_TAG_SPHERICAL_V2_POSE_PITCH, &ctag.pose_pitch_degrees_v2.value.i_val,
 413                                                 MM_FILE_TAG_SPHERICAL_V2_POSE_ROLL, &ctag.pose_roll_degrees_v2.value.i_val,
 414                                                 MM_FILE_TAG_SPHERICAL_V2_CBMP_LAYOUT, &ctag.cbmp_layout_v2.value.i_val,
 415                                                 MM_FILE_TAG_SPHERICAL_V2_CBMP_PADDING, &ctag.cbmp_padding_v2.value.i_val,
 416                                                 MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_TOP, &ctag.equi_projection_bounds_top_v2.value.i_val,
 417                                                 MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_BOTTOM, &ctag.equi_projection_bounds_bottom_v2.value.i_val,
 418                                                 MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_LEFT, &ctag.equi_projection_bounds_left_v2.value.i_val,
 419                                                 MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_RIGHT, &ctag.equi_projection_bounds_right_v2.value.i_val,
 420                                                 MM_FILE_TAG_SMTA, &ctag.smta.value.i_val,
 421                                                 NULL);
 422                 if (ret != FILEINFO_ERROR_NONE) {
 423                         printf("failed to get attrs\n");
 424
 425                         if (msg_tmp_fp) { /* opened by MM_TIME_CHECK_START */
 426                                 fclose(msg_tmp_fp);
 427                                 msg_tmp_fp = NULL;
 428                         }
 429                         mm_file_destroy_tag_attrs(tag_attrs);
 430                         return -1;
 431                 }
 432
 433                 /* print tag information         */
 434                 printf("[Tag] =================================== \n");
 435                 printf("# artist: [%s]\n", ctag.artist.value.s_val);
 436                 printf("# title: [%s]\n", ctag.title.value.s_val);
 437                 printf("# album: [%s]\n", ctag.album.value.s_val);
 438                 printf("# album_artist: [%s]\n", ctag.album_artist.value.s_val);
 439                 printf("# genre: [%s]\n", ctag.genre.value.s_val);
 440                 printf("# author: [%s]\n", ctag.author.value.s_val);
 441                 printf("# copyright: [%s]\n", ctag.copyright.value.s_val);
 442                 printf("# year: [%s]\n", ctag.date.value.s_val);
 443                 printf("# recdate: [%s]\n", ctag.recdate.value.s_val);
 444                 printf("# part of a set: [%s]\n", ctag.part_of_set.value.s_val);
 445                 printf("# description: [%s]\n", ctag.description.value.s_val);
 446                 printf("# comment: [%s]\n", ctag.comment.value.s_val);
 447                 printf("# artwork: [%p]\n", ctag.artwork.value.p_val);
 448                 printf("# artwork_size: [%d]\n", ctag.artwork_size.value.i_val);
 449                 printf("# artwork_mime: [%s]\n", ctag.artwork_mime.value.s_val);
 450                 printf("# track number: [%s]\n", ctag.track_num.value.s_val);
 451                 printf("# classification: [%s]\n", ctag.classfication.value.s_val);
 452                 printf("# rating: [%s]\n", ctag.rating.value.s_val);
 453                 printf("# longitude: [%f]\n", ctag.longitude.value.d_val);
 454                 printf("# latitude: [%f]\n", ctag.latitude.value.d_val);
 455                 printf("# altitude: [%f]\n", ctag.altitude.value.d_val);
 456                 printf("# conductor: [%s]\n", ctag.conductor.value.s_val);
 457                 printf("# unsynclyrics_length: [%d]\n", ctag.unsynclyrics.len);
 458                 printf("# unsynclyrics: [%s]\n", ctag.unsynclyrics.value.s_val);
 459                 printf("# synclyrics size: [%d]\n", ctag.synclyrics_size.value.i_val);
 460                 printf("# rotate: [%s]\n", ctag.rotate.value.s_val);
 461                 printf("# is_spherical: [%d]\n", ctag.is_spherical.value.i_val);
 462                 printf("# is_stitched: [%d]\n", ctag.is_stitched.value.i_val);
 463
 464                 if (ctag.is_spherical.value.i_val > 0 && ctag.is_stitched.value.i_val > 0) {
 465                         printf("# stitching_software: [%s]\n", ctag.stitching_software.value.s_val);
 466                         printf("# projection_type: [%s]\n", ctag.projection_type.value.s_val);
 467                         printf("# stereo_mode [%s]\n", ctag.stereo_mode.value.s_val);
 468                         printf("# source_count: [%d]\n", ctag.source_count.value.i_val);
 469                         printf("# init_view_heading: [%d]\n", ctag.init_view_heading.value.i_val);
 470                         printf("# init_view_pitch: [%d]\n", ctag.init_view_pitch.value.i_val);
 471                         printf("# init_view_roll: [%d]\n", ctag.init_view_roll.value.i_val);
 472                         printf("# time_stamp: [%d]\n", ctag.timestamp.value.i_val);
 473                         printf("# full_pano_width: [%d]\n", ctag.full_pano_width.value.i_val);
 474                         printf("# full_pano_height: [%d]\n", ctag.full_pano_height.value.i_val);
 475                         printf("# cropped_area_image_width: [%d]\n", ctag.cropped_area_image_width.value.i_val);
 476                         printf("# cropped_area_image_height: [%d]\n", ctag.cropped_area_image_height.value.i_val);
 477                         printf("# cropped_area_left: [%d]\n", ctag.cropped_area_left.value.i_val);
 478                         printf("# cropped_area_top: [%d]\n", ctag.cropped_area_top.value.i_val);
 479                 }
 480
 481                 printf("# ambisonic_type: [%d]\n", ctag.ambisonic_type.value.i_val);
 482
 483                 if (ctag.ambisonic_type.value.i_val > 0) {
 484                         printf("# ambisonic_format: [%d]\n", ctag.ambisonic_format.value.i_val);
 485                         printf("# ambisonic_order: [%d]\n", ctag.ambisonic_order.value.i_val);
 486                 }
 487
 488                 printf("# stereo_mode_v2: [%d]\n", ctag.stereo_mode_v2.value.i_val);
 489
 490                 if (ctag.proj_type_v2.value.i_val >= 0) {
 491                         printf("# proj_type_v2: [%d]\n", ctag.proj_type_v2.value.i_val);
 492                         printf("# metadata_source_v2: [%s]\n", ctag.metadata_source_v2.value.s_val);
 493                         printf("# pose_yaw_degrees_v2: [%d]\n", ctag.pose_yaw_degrees_v2.value.i_val);
 494                         printf("# pose_pitch_degrees_v2: [%d]\n", ctag.pose_pitch_degrees_v2.value.i_val);
 495                         printf("# pose_roll_degrees_v2: [%d]\n", ctag.pose_roll_degrees_v2.value.i_val);
 496                         printf("# cbmp_layout_v2: [%d]\n", ctag.cbmp_layout_v2.value.i_val);
 497                         printf("# cbmp_padding_v2: [%d]\n", ctag.cbmp_padding_v2.value.i_val);
 498                         printf("# equi_projection_bounds_top_v2: [%d]\n", ctag.equi_projection_bounds_top_v2.value.i_val);
 499                         printf("# equi_projection_bounds_bottom_v2: [%d]\n", ctag.equi_projection_bounds_bottom_v2.value.i_val);
 500                         printf("# equi_projection_bounds_left_v2: [%d]\n", ctag.equi_projection_bounds_left_v2.value.i_val);
 501                         printf("# equi_projection_bounds_right_v2: [%d]\n", ctag.equi_projection_bounds_right_v2.value.i_val);
 502                 }
 503
 504                 printf("# smta: [%d]\n", ctag.smta.value.i_val);
 505
 506                 if (ctag.synclyrics_size.value.i_val > 0) {
 507                         int idx = 0;
 508                         unsigned long time_info = 0;
 509                         char *lyrics_info = NULL;
 510
 511                         printf("# synclyrics: \n");
 512
 513                         for (idx = 0; idx < ctag.synclyrics_size.value.i_val; idx++) {
 514                                 ret = mm_file_get_synclyrics_info(tag_attrs, idx, &time_info, &lyrics_info);
 515                                 if (ret == FILEINFO_ERROR_NONE) {
 516                                         printf("[%2d][%6ld][%s]\n", idx, time_info, lyrics_info);
 517                                 } else {
 518                                         printf("Error when get lyrics\n");
 519                                         break;
 520                                 }
 521                         }
 522                 }
 523
 524                 /* release tag */
 525                 ret = mm_file_destroy_tag_attrs(tag_attrs);
 526                 if (ret != FILEINFO_ERROR_NONE) {
 527                         printf("Error mm_file_destroy_tag_attrs: %d", ret);
 528                         if (msg_tmp_fp) {
 529                                 fclose(msg_tmp_fp);
 530                                 msg_tmp_fp = NULL;
 531                         }
 532                         return -1;
 533                 }
 534         } else {
 535                 printf("Failed to mm_file_create_tag_attrs() error=[%x]\n", ret);
 536         }
 537
 538
 539         printf("=================================================\n\n");
 540
 541         MM_TIME_CHECK_FINISH(filename);
 542
 543         return 0;
 544 }
 545
 546 static int mmfile_get_video_frame(void *data, void *accurate, bool file_test)
 547 {
 548         int ret = 0;
 549         char filename[512] = {0, };
 550         char accurate_mode[10] = {0, };
 551         void *_frame = NULL;
 552         int _frame_size = 0;
 553         int width = 0;
 554         int height = 0;
 555         bool is_accurate = FALSE;
 556         unsigned long long time_stamp = 5 * 1000 * 1000;                //5sec
 557
 558         memset(filename, 0x00, sizeof(filename));
 559         SAFE_STRLCPY(filename, (char *)data, sizeof(filename));
 560
 561         memset(accurate_mode, 0x00, sizeof(accurate_mode));
 562         SAFE_STRLCPY(accurate_mode, (char *)accurate, sizeof(accurate_mode));
 563
 564         if (strlen(accurate_mode) > 0) {
 565                 if (strncmp(accurate_mode, "1", 1) == 0)
 566                         is_accurate = TRUE;
 567         }
 568
 569         printf("Extracting video frame for [%s] [%llu] accurate [%d]\n", filename, time_stamp, is_accurate);
 570
 571         if (file_test == TRUE)
 572                 ret = mm_file_get_video_frame(filename, time_stamp, is_accurate, (unsigned char **)&_frame, &_frame_size, &width, &height);
 573         else    {
 574                 unsigned int file_size = 0;
 575                 unsigned char *buffer = NULL;
 576                 /* Read file */
 577                 READ_FROM_FILE(filename, buffer, file_size);
 578
 579                 ret = mm_file_get_video_frame_from_memory(buffer, file_size, time_stamp, is_accurate, (unsigned char **)&_frame, &_frame_size, &width, &height);
 580                 SAFE_FREE(buffer);
 581         }
 582
 583         if (ret != FILEINFO_ERROR_NONE)
 584                 printf("Failed to mm_file_get_video_frame() error=[%x]\n", ret);
 585         else
 586                 printf("video_frame[%p], video_frame_len = [%d] width = [%d] height = [%d]\n", _frame, _frame_size, width, height);
 587
 588         return 0;
 589 }