formats/ffmpeg/mm_file_format_mp3.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>     /*memcmp*/
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>   /*stat*/
  26 #include <unistd.h>
  27
  28 #include <stdlib.h>     /*malloc*/
  29
  30 #include "mm_debug.h"
  31 #include "mm_file_utils.h"
  32 #include "mm_file_format_private.h"
  33 #include "mm_file_format_audio.h"
  34 #include "mm_file_format_mp3.h"
  35
  36
  37 #define __MMFILE_NEW_FRAME_FUNC
  38
  39 #ifdef __MMFILE_NEW_TAGLIBS__
  40 #include "mm_file_format_tags.h"
  41 #endif
  42
  43
  44 #define AV_MP3_FIND_SYNC_LEN            1024*30
  45 #undef MIN
  46 #define MIN(a, b) ((a) < (b) ? (a) : (b))
  47
  48
  49 static const unsigned char mp3FrameMasking[4] = {0xFF,0xFE,0x0C,0x00};
  50 static unsigned char mp3FrameDataValid[4];
  51
  52 static const int mp3BitRateTable[2][3][16] = {
  53         {       {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
  54                 {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
  55                 {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,}       },
  56
  57         {       {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
  58                 {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
  59                 {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}       }
  60 };
  61
  62 static const int mp3SamRateTable[3][3] =
  63 {       {44100, 48000, 32000},
  64         {22050, 24000, 16000} ,
  65         {11025, 12000, 8000}
  66 };
  67
  68 #define IS_VALID_FRAME_MP3(x) \
  69   ((((x)[0] & mp3FrameMasking[0]) == mp3FrameDataValid[0]) && \
  70    (((x)[1] & mp3FrameMasking[1]) == mp3FrameDataValid[1]) && \
  71    (((x)[2] & mp3FrameMasking[2]) == mp3FrameDataValid[2]) && \
  72    (((x)[3] & mp3FrameMasking[3]) == mp3FrameDataValid[3]))
  73
  74
  75
  76 /* interface functions */
  77 int mmfile_format_read_stream_mp3 (MMFileFormatContext *formatContext);
  78 int mmfile_format_read_frame_mp3  (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
  79 int mmfile_format_read_tag_mp3    (MMFileFormatContext *formatContext);
  80 int mmfile_format_close_mp3       (MMFileFormatContext *formatContext);
  81
  82 /* internal */
  83 static int mmf_file_mp3_get_infomation (char *src, AvFileContentInfo* pInfo );
  84
  85 EXPORT_API
  86 int mmfile_format_open_mp3 (MMFileFormatContext *formatContext)
  87 {
  88     AvFileContentInfo *privateData = NULL;;
  89     int ret = 0;
  90
  91         debug_fenter();
  92
  93     if (NULL == formatContext)
  94     {
  95         debug_error("formatContext is NULL\n");
  96         return MMFILE_FORMAT_FAIL;
  97     }
  98
  99         if (formatContext->pre_checked == 0) {
 100                 ret = MMFileFormatIsValidMP3 (formatContext->uriFileName,5);
 101                 if ( ret == 0 )
 102                 {
 103                         debug_error("It is not mp3 file\n");
 104                         return MMFILE_FORMAT_FAIL;
 105                 }
 106         }
 107
 108
 109     formatContext->ReadStream   = mmfile_format_read_stream_mp3;
 110     formatContext->ReadFrame    = mmfile_format_read_frame_mp3;
 111     formatContext->ReadTag      = mmfile_format_read_tag_mp3;
 112     formatContext->Close        = mmfile_format_close_mp3;
 113
 114     formatContext->videoTotalTrackNum = 0;
 115     formatContext->audioTotalTrackNum = 1;
 116
 117     privateData = mmfile_malloc (sizeof (AvFileContentInfo));
 118     if (!privateData)
 119     {
 120         debug_error ("error: mmfile_malloc MP3 privateData\n");
 121         return MMFILE_FORMAT_FAIL;
 122     }
 123
 124     formatContext->privateFormatData = privateData;
 125
 126     ret = mmf_file_mp3_get_infomation (formatContext->uriFileName, privateData);
 127     if ( ret == -1 )
 128     {
 129         debug_error ("error: mmfile_format_read_stream_mp3\n");
 130         goto exception;
 131     }
 132
 133     return MMFILE_FORMAT_SUCCESS;
 134
 135 exception:
 136     mmfile_format_close_mp3 (formatContext);
 137     return MMFILE_FORMAT_FAIL;
 138 }
 139
 140
 141 EXPORT_API
 142 int mmfile_format_read_stream_mp3 (MMFileFormatContext *formatContext)
 143 {
 144     AvFileContentInfo *privateData = NULL;
 145         debug_fenter();
 146
 147     if (!formatContext || !formatContext->privateFormatData)
 148     {
 149         debug_error("formatContext is NULL\n");
 150         return MMFILE_FORMAT_FAIL;
 151     }
 152
 153     privateData = formatContext->privateFormatData;
 154
 155     formatContext->duration = privateData->duration;
 156     formatContext->videoTotalTrackNum = 0;
 157     formatContext->audioTotalTrackNum = 1;
 158     formatContext->nbStreams = 1;
 159     formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc (sizeof (MMFileFormatStream));
 160     if (NULL == formatContext->streams[MMFILE_AUDIO_STREAM])
 161     {
 162         debug_error ("formatContext->streams[MMFILE_AUDIO_STREAM] is NULL\n");
 163         return MMFILE_FORMAT_FAIL;
 164     }
 165
 166     formatContext->streams[MMFILE_AUDIO_STREAM]->streamType = MMFILE_AUDIO_STREAM;
 167     formatContext->streams[MMFILE_AUDIO_STREAM]->codecId = MM_AUDIO_CODEC_MP3;
 168     formatContext->streams[MMFILE_AUDIO_STREAM]->bitRate = (privateData->bitRate*1000);
 169     formatContext->streams[MMFILE_AUDIO_STREAM]->framePerSec = (privateData->duration == 0 ? 0 : privateData->frameNum/privateData->duration);
 170     formatContext->streams[MMFILE_AUDIO_STREAM]->width = 0;
 171     formatContext->streams[MMFILE_AUDIO_STREAM]->height = 0;
 172     formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = privateData->channels;
 173     formatContext->streams[MMFILE_AUDIO_STREAM]->samplePerSec = privateData->sampleRate;
 174
 175     return MMFILE_FORMAT_SUCCESS;
 176 }
 177
 178
 179 EXPORT_API
 180 int mmfile_format_read_frame_mp3  (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
 181 {
 182     return MMFILE_FORMAT_SUCCESS;
 183 }
 184
 185 EXPORT_API
 186 int mmfile_format_read_tag_mp3    (MMFileFormatContext *formatContext)
 187 {
 188     AvFileContentInfo *privateData = NULL;
 189         debug_fenter();
 190
 191     if (!formatContext || !formatContext->privateFormatData)
 192     {
 193         debug_error("formatContext is NULL\n");
 194         return MMFILE_FORMAT_FAIL;
 195     }
 196
 197     privateData = formatContext->privateFormatData;
 198
 199         if (privateData->pTitle)                                formatContext->title = mmfile_strdup(privateData->pTitle);
 200         if (privateData->pArtist)                       formatContext->artist = mmfile_strdup(privateData->pArtist);
 201         if (privateData->pAuthor)                       formatContext->author = mmfile_strdup(privateData->pAuthor);
 202         if (privateData->pCopyright)            formatContext->copyright = mmfile_strdup(privateData->pCopyright);
 203         if (privateData->pComment)              formatContext->comment = mmfile_strdup(privateData->pComment);
 204         if (privateData->pAlbum)                        formatContext->album = mmfile_strdup(privateData->pAlbum);
 205         if (privateData->pYear)                         formatContext->year = mmfile_strdup(privateData->pYear);
 206         if (privateData->pGenre)                        formatContext->genre = mmfile_strdup(privateData->pGenre);
 207         if (privateData->pTrackNum)             formatContext->tagTrackNum = mmfile_strdup(privateData->pTrackNum);
 208         if (privateData->pComposer)             formatContext->composer = mmfile_strdup(privateData->pComposer);
 209         if (privateData->pContentGroup) formatContext->classification = mmfile_strdup(privateData->pContentGroup);
 210         if (privateData->pConductor)            formatContext->conductor = mmfile_strdup(privateData->pConductor);
 211         if (privateData->pUnsyncLyrics)         formatContext->unsyncLyrics= mmfile_strdup(privateData->pUnsyncLyrics);
 212         if (privateData->pSyncLyrics)           formatContext->syncLyrics= privateData->pSyncLyrics;
 213         if (privateData->syncLyricsNum)         formatContext->syncLyricsNum= privateData->syncLyricsNum;
 214         if (privateData->pRecDate)                      formatContext->recDate= mmfile_strdup(privateData->pRecDate);
 215
 216         if(privateData->imageInfo.imageLen > 0)
 217         {
 218                 formatContext->artwork = mmfile_malloc (privateData->imageInfo.imageLen);
 219                 if(formatContext->artwork)
 220                 {
 221                         formatContext->artworkSize = privateData->imageInfo.imageLen;
 222                         memcpy (formatContext->artwork, privateData->imageInfo.pImageBuf, privateData->imageInfo.imageLen);
 223                         if (strlen(privateData->imageInfo.imageMIMEType) > 0)
 224                                 formatContext->artworkMime= mmfile_strdup(privateData->imageInfo.imageMIMEType);
 225                         else if(strlen(privateData->imageInfo.imageExt) > 0) {
 226                                 debug_msg("ID3 tag V2 File");
 227                                 formatContext->artworkMime= mmfile_strdup(privateData->imageInfo.imageExt);
 228                         }
 229                         else {
 230                                 debug_error("Album art image exist but there is no type information of album art\n");
 231                         }
 232                 }
 233         }
 234
 235         return MMFILE_FORMAT_SUCCESS;
 236 }
 237
 238 EXPORT_API
 239 int mmfile_format_close_mp3 (MMFileFormatContext *formatContext)
 240 {
 241     AvFileContentInfo *privateData = NULL;
 242
 243     if (formatContext)
 244     {
 245         privateData = formatContext->privateFormatData;
 246         if (privateData)
 247         {
 248             mm_file_free_AvFileContentInfo (privateData);
 249             mmfile_free (privateData);
 250             formatContext->privateFormatData = NULL;
 251         }
 252     }
 253
 254     return MMFILE_FORMAT_SUCCESS;
 255 }
 256
 257 static int
 258 __AvExtractI4(unsigned char *buf)
 259 {
 260         int I4;
 261
 262         I4 = buf[0];
 263         I4 <<= 8;
 264         I4 |= buf[1];
 265         I4 <<= 8;
 266         I4 |= buf[2];
 267         I4 <<= 8;
 268         I4 |= buf[3];
 269
 270         return I4;
 271 }
 272
 273 static int
 274 __AvExtractI2(unsigned char *buf)
 275 {
 276         int I2;
 277
 278         I2 = buf[0];
 279         I2 <<= 8;
 280         I2 |= buf[1];
 281         I2 <<= 8;
 282
 283         return I2;
 284 }
 285
 286 static int
 287 __AvGetXingHeader( AvXHeadData* headData,  unsigned char *buf )
 288 {
 289         int                     index, headFlags;
 290         int                     hId, hMode, hSrIndex;
 291         static int      mp3SamRateTable[4] = { 44100, 48000, 32000, 99999 };
 292
 293         // get Xing header data
 294         headData->flags = 0;
 295
 296         // get selected MP3 header data
 297         hId                     = (buf[1] >> 3) & 1;
 298         hSrIndex        = (buf[2] >> 2) & 3;
 299         hMode           = (buf[3] >> 6) & 3;
 300
 301
 302         // determine offset of header
 303         if( hId )       // mpeg1
 304         {
 305                 if( hMode != 3 )
 306                         buf += (32+4);
 307                 else
 308                         buf += (17+4);
 309         }
 310         else            // mpeg2
 311         {
 312                 if( hMode != 3 )
 313                         buf += (17+4);
 314                 else
 315                         buf += (9+4);
 316         }
 317
 318         /* There could be 2 attrs in this header : Xing or Info */
 319         if (buf[0] == 'X') {
 320                 if( buf[1] != 'i' ) return 0;
 321                 if( buf[2] != 'n' ) return 0;
 322                 if( buf[3] != 'g' ) return 0;
 323         } else if (buf[0] == 'I') {
 324                 if( buf[1] != 'n' ) return 0;
 325                 if( buf[2] != 'f' ) return 0;
 326                 if( buf[3] != 'o' ) return 0;
 327         } else {
 328                 return 0;
 329         }
 330
 331         buf += 4;
 332
 333         headData->hId = hId;
 334         headData->sampRate = mp3SamRateTable[hSrIndex];
 335         if( hId == 0 )
 336                 headData->sampRate >>= 1;
 337
 338         headFlags = headData->flags = __AvExtractI4( buf );             // get flags
 339         buf+=4;
 340
 341         if( headFlags & FRAMES_FLAG )
 342         {
 343                 headData->frames   = __AvExtractI4( buf );
 344                 buf+=4;
 345         }
 346         if( headFlags & BYTES_FLAG )
 347         {
 348                 headData->bytes = __AvExtractI4( buf );
 349                 buf+=4;
 350         }
 351
 352         if( headFlags & TOC_FLAG )
 353         {
 354                 if( headData->toc != NULL )
 355                 {
 356                         for( index = 0; index < 100; index++ )
 357                                 headData->toc[index] = buf[index];
 358                 }
 359                 buf+=100;
 360         }
 361
 362         headData->vbrScale = -1;
 363         if( headFlags & VBR_SCALE_FLAG )
 364         {
 365                 headData->vbrScale = __AvExtractI4( buf );
 366                 buf+=4;
 367         }
 368
 369         #ifdef __MMFILE_TEST_MODE__
 370         debug_msg ("Xing header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
 371                 headData->sampRate, headData->bytes, headData->frames);
 372         #endif
 373
 374         return 1;       // success
 375 }
 376
 377 static int
 378 __AvGetVBRIHeader( AvVBRIHeadData* headData,  unsigned char *buf )
 379 {
 380         int                     hId, hSrIndex;
 381         static int      mp3SamRateTable[4] = { 44100, 48000, 32000, 99999 };
 382
 383
 384         // get selected MP3 header data
 385         hId                     = (buf[1] >> 3) & 1;
 386         hSrIndex        = (buf[2] >> 2) & 3;
 387
 388         buf += (32+4);
 389
 390         if( buf[0] != 'V' ) return 0;    // fail
 391         if( buf[1] != 'B' ) return 0;    // header not found
 392         if( buf[2] != 'R' ) return 0;
 393         if( buf[3] != 'I' ) return 0;
 394         buf += 4;
 395
 396         headData->hId = hId;
 397         headData->sampRate = mp3SamRateTable[hSrIndex];
 398         if( hId == 0 )
 399                 headData->sampRate >>= 1;
 400
 401         headData->vID = __AvExtractI2( buf );           // get ver ID
 402         buf+=2;
 403         headData->delay = __AvExtractI2( buf );
 404         buf+=2;
 405         headData->qualityIndicator = buf[0];
 406         buf+=2;
 407         headData->bytes = __AvExtractI4( buf );
 408         buf+=4;
 409         headData->frames= __AvExtractI4( buf );
 410         buf+=4;
 411         headData->numOfTOC = __AvExtractI2( buf );
 412         buf+=2;
 413         headData->vbriScale = __AvExtractI2( buf );
 414         buf+=2;
 415         headData->sizePerTable = __AvExtractI2( buf );
 416         buf+=2;
 417         headData->framesPerTable = __AvExtractI2( buf );
 418         buf+=2;
 419
 420         #ifdef __MMFILE_TEST_MODE__
 421         debug_msg ("Vbri header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
 422                 headData->sampRate, headData->bytes, headData->frames);
 423         #endif
 424
 425         return true;       // success
 426 }
 427 static bool
 428 __AvIsValidHeader(AvFileContentInfo* pInfo, unsigned char *buf)
 429 {
 430         bool    bSync = false;
 431
 432         if (VALID_SYNC(buf))
 433         {
 434                 mp3FrameDataValid[0] = (0xFF) & (mp3FrameMasking[0]);
 435                 mp3FrameDataValid[1] = (0xE0 | (buf[AV_MP3HDR_VERSION_OFS] & AV_MP3HDR_VERSION_M)
 436                                                 | (buf[AV_MP3HDR_LAYER_OFS] & AV_MP3HDR_LAYER_M)) & (mp3FrameMasking[1]);
 437                 mp3FrameDataValid[2] = (buf[AV_MP3HDR_SAMPLERATE_OFS] & AV_MP3HDR_SAMPLERATE_M) &
 438                                                 (mp3FrameMasking[2]);
 439                 mp3FrameDataValid[3] = (buf[AV_MP3HDR_CHANNEL_OFS] & AV_MP3HDR_CHANNEL_M) &
 440                                                 (mp3FrameMasking[3]);
 441
 442                 #ifdef __MMFILE_TEST_MODE__
 443                 debug_msg ("*** [%02x][%02x][%02x][%02x] : [%02x][%02x][%02x][%02x]",
 444                                 buf[0], buf[1], buf[2],buf[3],
 445                                 mp3FrameDataValid[0], mp3FrameDataValid[1], mp3FrameDataValid[2],mp3FrameDataValid[3]);
 446                 #endif
 447
 448                 /*
 449                  * MPEG Audio Layer I/II/III frame header
 450                  * from : http://www.mp3-tech.org/programmer/frame_header.html           *
 451                  *
 452                  * AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM
 453                  *
 454                  * A    11      (31-21)         Frame sync (all bits must be set)
 455                  * B    2       (20,19)         MPEG Audio version ID
 456                  * C    2       (18,17)         Layer description
 457                  * D    1       (16)    Protection bit
 458                  * E    4       (15,12)         Bitrate index
 459                  * F    2       (11,10)         Sampling rate frequency index
 460                  * G    1       (9)     Padding bit
 461                  * H    1       (8)     Private bit. This one is only informative.
 462                  * I    2       (7,6)   Channel Mode
 463                  * J    2       (5,4)   Mode extension (Only used in Joint stereo)
 464                  * K    1       (3)     Copyright
 465                  * L    1       (2)     Original
 466                  * M    2       (1,0)   Emphasis
 467                  *
 468                  */
 469
 470                 /* Simple check for version, layer, bitrate, samplerate */
 471                 if (    (buf[1] & 0x18) != 0x08 && /* 000XX000 : MPEG Audio version ID, XX=01 - reserved => 00001000(0x08) */
 472                         (buf[1] & 0x06) != 0x00 && /* 00000XX0 : Layer description, XX=00 - reserved => 00000000(0x00) */
 473                         (buf[2] & 0xF0) != 0xF0 && /* XXXX0000 : Bitrate index, XX=1111 - bad => 11110000(0xF0) */
 474                         (buf[2] & 0x0C) != 0x0C)   /* 0000XX00 : Sampling rate frequency index , XX=11 -reserved => 00001100(0x0C) */
 475                 {
 476                         bSync = true;
 477                 }
 478                 #ifdef __MMFILE_TEST_MODE__
 479                 debug_msg ("=> %s\n", bSync? "Good!":"Bad...");
 480                 #endif
 481         }
 482
 483         if(bSync == true)
 484                 return true;
 485         else
 486                 return false;
 487 }
 488
 489 static bool
 490 __AvParseMp3Header( AvFileContentInfo* pInfo,  unsigned char* header )
 491 {
 492         unsigned char   result;
 493
 494         #ifdef __MMFILE_TEST_MODE__
 495         debug_msg  ("### [%02x][%02x][%02x][%02x] ###\n", header[0], header[1], header[2],header[3]);
 496         #endif
 497
 498         // 1. Check the version of mp3
 499         result = header[1] & MASK_MPEG;
 500         switch (result)
 501         {
 502         case MASK_MPEG_1:
 503                 pInfo->mpegVersion = AV_MPEG_VER_1;
 504                 break;
 505         case MASK_MPEG_2:
 506                 pInfo->mpegVersion = AV_MPEG_VER_2;
 507                 break;
 508         case MASK_MPEG_25:
 509                 pInfo->mpegVersion = AV_MPEG_VER_25;
 510                 break;
 511         default:
 512                 return false;
 513         }
 514
 515         // 2. Get a layer
 516         result = header[1] & MASK_LAYER;
 517         switch (result)
 518         {
 519         case MASK_LAYER_1:
 520                 pInfo->layer = AV_MP3_LAYER_1;
 521                 break;
 522         case MASK_LAYER_2:
 523                 pInfo->layer = AV_MP3_LAYER_2;
 524                 break;
 525         case MASK_LAYER_3:
 526                 pInfo->layer = AV_MP3_LAYER_3;
 527                 break;
 528         default:
 529                 return false;
 530         }
 531
 532         // 3. bitrate
 533         result = header[2] >> 4;
 534         if ( pInfo->mpegVersion == AV_MPEG_VER_1 )
 535                 pInfo->bitRate = mp3BitRateTable[0][pInfo->layer-1][(int)result] ;
 536         else
 537                 pInfo->bitRate = mp3BitRateTable[1][pInfo->layer-1][(int)result] ;
 538
 539         // 4. samplerate
 540         result = ( header[2] & MASK_SAMPLERATE ) >> 2;
 541         if ( result == 0x03 )
 542                 return false;
 543         else
 544                 pInfo->sampleRate = mp3SamRateTable[pInfo->mpegVersion - 1][(int)result];
 545
 546         // 5. channel
 547         result = header[3] & MASK_CHANNEL;
 548         switch (result)
 549         {
 550         case MASK_CHANNEL_ST:
 551                 pInfo->channelIndex = 0;
 552                 pInfo->channels = 2;
 553                 break;
 554         case MASK_CHANNEL_JS:
 555                 pInfo->channelIndex = 1;
 556                 pInfo->channels = 2;
 557                 break;
 558         case MASK_CHANNEL_DC:
 559                 pInfo->channelIndex = 2;
 560                 pInfo->channels = 2;
 561                 break;
 562         case MASK_CHANNEL_MN:
 563                 pInfo->channelIndex = 3;;
 564                 pInfo->channels = 1;
 565                 break;
 566         default:
 567                 return false;
 568         }
 569
 570         //      6. padding
 571         result = header[2] & MASK_PADDING;
 572         if ( result == MASK_PADDING )
 573                 pInfo->bPadding = true;
 574         else
 575                 pInfo->bPadding = false;
 576
 577         #ifdef __MMFILE_TEST_MODE__
 578         debug_msg ("=> samplerate=%d, bitrate=%d, layer=%d, version=%d, channel=%d, padding=%d",
 579                          pInfo->sampleRate, pInfo->bitRate, pInfo->layer, pInfo->mpegVersion, pInfo->channels, pInfo->bPadding  );
 580         #endif
 581
 582         return true;
 583 }
 584
 585 static bool
 586 __AvParseXingHeader( AvFileContentInfo* pInfo, unsigned char* buf )
 587 {
 588         AvXHeadData data;
 589         memset( &data, 0x00, sizeof(AvXHeadData) );
 590
 591         //      1. Xing Header
 592         /* There could be 2 attrs in this header : Xing or Info */
 593         if((pInfo->mpegVersion == AV_MPEG_VER_1) && (pInfo->channels == 2))
 594         {
 595                 if (buf[36] =='X') {
 596                         if( buf[37] != 'i' ) return false;
 597                         if( buf[38] != 'n' ) return false;
 598                         if( buf[39] != 'g' ) return false;
 599                 } else if (buf[36] == 'I') {
 600                         if( buf[37] != 'n' ) return false;
 601                         if( buf[38] != 'f' ) return false;
 602                         if( buf[39] != 'o' ) return false;
 603                 } else {
 604                         return false;
 605                 }
 606         }
 607         else
 608         if((pInfo->mpegVersion == AV_MPEG_VER_2 || pInfo->mpegVersion == AV_MPEG_VER_25) && (pInfo->channels == 1))
 609         {
 610                 if (buf[13] =='X') {
 611                         if( buf[14] != 'i' ) return false;
 612                         if( buf[15] != 'n' ) return false;
 613                         if( buf[16] != 'g' ) return false;
 614                 } else if (buf[13] == 'I') {
 615                         if( buf[14] != 'n' ) return false;
 616                         if( buf[15] != 'f' ) return false;
 617                         if( buf[16] != 'o' ) return false;
 618                 } else {
 619                         return false;
 620                 }
 621         }
 622         else
 623         {
 624                 if (buf[21] =='X') {
 625                         if( buf[22] != 'i' ) return false;
 626                         if( buf[23] != 'n' ) return false;
 627                         if( buf[24] != 'g' ) return false;
 628                 } else if (buf[21] == 'I') {
 629                         if( buf[22] != 'n' ) return false;
 630                         if( buf[23] != 'f' ) return false;
 631                         if( buf[24] != 'o' ) return false;
 632                 } else {
 633                         return false;
 634                 }
 635         }
 636
 637         //      2. TOC
 638         if ( pInfo->pToc )
 639                 data.toc = (unsigned char *)(pInfo->pToc);
 640
 641         if ( __AvGetXingHeader( &data, (unsigned char *)buf ) == 1 ) // VBR.
 642         {
 643                 if (data.sampRate == 0 || data.bytes == 0 || data.frames == 0) {
 644                         debug_error ("invalid Xing header\n");
 645                         return false;
 646                 }
 647
 648                 pInfo->datafileLen = data.bytes;
 649                 pInfo->frameNum = data.frames;
 650                 pInfo->frameSize = (int) ( (float) data.bytes / (float) data.frames )  ;
 651                 pInfo->bVbr = true;
 652                 return true;
 653         }
 654         else
 655                 return false;
 656 }
 657
 658 static bool
 659 __AvParseVBRIHeader( AvFileContentInfo* pInfo, unsigned char* buf )
 660 {
 661         AvVBRIHeadData data;
 662         memset( &data, 0x00, sizeof(AvVBRIHeadData) );
 663
 664         //      1. Xing Header
 665         if((pInfo->mpegVersion == AV_MPEG_VER_1) && (pInfo->channels == 2))
 666         {
 667                 if( buf[36] != 'V' ) return false;
 668                 if( buf[37] != 'B' ) return false;
 669                 if( buf[38] != 'R' ) return false;
 670                 if( buf[39] != 'I' ) return false;
 671         }
 672         else
 673         if((pInfo->mpegVersion == AV_MPEG_VER_2) && (pInfo->channels == 1))
 674         {
 675                 if( buf[36] != 'V' ) return false;
 676                 if( buf[37] != 'B' ) return false;
 677                 if( buf[38] != 'R' ) return false;
 678                 if( buf[39] != 'I' ) return false;
 679         }
 680         else
 681         {
 682                 if( buf[36] != 'V' ) return false;
 683                 if( buf[37] != 'B' ) return false;
 684                 if( buf[38] != 'R' ) return false;
 685                 if( buf[39] != 'I' ) return false;
 686         }
 687
 688         //      2. TOC
 689         if ( pInfo->pToc )
 690                 data.toc = (unsigned char*)(pInfo->pToc);
 691
 692         if ( __AvGetVBRIHeader( &data, (unsigned char*)buf ) == 1 ) // VBR.
 693         {
 694                 if (data.sampRate == 0 || data.bytes == 0 || data.frames == 0) {
 695                         debug_error ("invalid Vbri header\n");
 696                         return false;
 697                 }
 698
 699                 pInfo->sampleRate = data.sampRate;
 700                 pInfo->datafileLen = data.bytes;
 701                 pInfo->frameNum = data.frames;
 702                 pInfo->frameSize = (int) ( (float) data.bytes / (float) data.frames )  ;
 703                 pInfo->bVbr = true;
 704                 return true;
 705         }
 706         else
 707                 return false;
 708 }
 709
 710 #ifdef __MMFILE_NEW_FRAME_FUNC // from gst
 711 static bool
 712 __AvGetMp3FrameSize( AvFileContentInfo* pInfo )
 713 {
 714         unsigned int frameSize = 0;
 715         if ( pInfo == NULL )
 716                 return false;
 717
 718         frameSize =  pInfo->bPadding;
 719          if (pInfo->bitRate == 0) {
 720            if (pInfo->layer == 1) {
 721                    frameSize *= 4;
 722                    frameSize += 0/* FIXME: possible_free_framelen*/;
 723                    pInfo->bitRate = frameSize * pInfo->sampleRate / 48000;
 724            } else {
 725                    frameSize += 0/* FIXME: possible_free_framelen*/;
 726                    pInfo->bitRate = frameSize * pInfo->sampleRate /
 727                  ((pInfo->layer == AV_MP3_LAYER_3 && pInfo->mpegVersion != AV_MPEG_VER_1) ? 72000 : 144000);
 728            }
 729          } else {
 730            /* calculating */
 731            if (pInfo->layer == 1) {
 732                    frameSize = ((12000 * pInfo->bitRate / pInfo->sampleRate) + frameSize) * 4;
 733            } else {
 734                    frameSize += ((pInfo->layer == AV_MP3_LAYER_3
 735                      && pInfo->mpegVersion != AV_MPEG_VER_1) ? 72000 : 144000) * pInfo->bitRate / pInfo->sampleRate;
 736            }
 737          }
 738
 739         pInfo->frameSize = (int)frameSize;
 740
 741         return true;
 742 }
 743 #endif
 744
 745
 746 static bool
 747 __AvGetXingBitrate( AvFileContentInfo* pInfo )
 748 {
 749         float   br, factor;
 750         int             padding;
 751
 752         if ( pInfo == NULL || pInfo->bVbr == false )
 753                 return false;
 754
 755         if ( pInfo->bPadding )
 756                 padding = 1;
 757         else
 758                 padding = 0;
 759
 760         if (pInfo->mpegVersion == AV_MPEG_VER_1 )       // MPEG version 1
 761         {
 762                 if (pInfo->layer == AV_MP3_LAYER_1 )    // Layer 1
 763                         factor = 48000.0;
 764                 else                                            // Layer 2, 3
 765                         factor = 144000.0;
 766         }
 767         else                                                    // MPEG version 2
 768         {
 769                 if (pInfo->layer == AV_MP3_LAYER_1 )    //      Layer 1
 770                         factor = 24000.0;
 771                 else                                            //      Layer 2, 3
 772                         factor = 72000.0;
 773         }
 774
 775         br = ( pInfo->frameSize - padding ) * pInfo->sampleRate / factor;
 776
 777         pInfo->bitRate = (int) br;
 778
 779         return true;
 780 }
 781
 782 static bool
 783 __AvGetVBRIBitrate( AvFileContentInfo* pInfo )
 784 {
 785         float   br, factor;
 786         int             padding;
 787
 788         if ( pInfo == NULL || pInfo->bVbr == false )
 789                 return false;
 790
 791         if ( pInfo->bPadding )
 792                 padding = 1;
 793         else
 794                 padding = 0;
 795
 796         if (pInfo->mpegVersion == AV_MPEG_VER_1 )       // MPEG version 1
 797         {
 798                 if (pInfo->layer == AV_MP3_LAYER_1 )    // Layer 1
 799                         factor = 48000.0;
 800                 else                                            // Layer 2, 3
 801                         factor = 144000.0;
 802         }
 803         else                                                    // MPEG version 2
 804         {
 805                 if (pInfo->layer == AV_MP3_LAYER_1 )    //      Layer 1
 806                         factor = 24000.0;
 807                 else                                            //      Layer 2, 3
 808                         factor = 72000.0;
 809         }
 810
 811         br = ( pInfo->frameSize - padding ) * pInfo->sampleRate / factor;
 812
 813         pInfo->bitRate = (int) br;
 814
 815         return true;
 816 }
 817
 818 static int __AvGetLastID3offset (MMFileIOHandle *fp, unsigned int *offset)
 819 {
 820 #define _MMFILE_MP3_TAGV2_HEADER_LEN 10
 821 #define _MMFILE_GET_INT_NUMBER(buff) (int)( (((int)(buff)[0]) << 24) | (((int)(buff)[1]) << 16) | (((int)(buff)[2]) << 8) | (((int)(buff)[3])))
 822
 823         unsigned char tagHeader[_MMFILE_MP3_TAGV2_HEADER_LEN] = {0,};
 824         unsigned int tagInfoSize = 0;
 825         unsigned int acc_tagsize = 0;
 826         int tagVersion = 0;
 827         int encSize = 0;
 828         int readed = 0;
 829
 830         /*init offset*/
 831         *offset = 0;
 832
 833         mmfile_seek(fp, 0, MMFILE_SEEK_SET);
 834
 835 _START_TAG_SEARCH:
 836
 837         readed = mmfile_read (fp, tagHeader, _MMFILE_MP3_TAGV2_HEADER_LEN);
 838         if (readed != _MMFILE_MP3_TAGV2_HEADER_LEN) {
 839                 debug_error ("read error occured.\n");
 840                 return 0;
 841         }
 842
 843         if (memcmp (tagHeader, "ID3", 3) == 0) {
 844                 #ifdef __MMFILE_TEST_MODE__
 845                 debug_msg ("'ID3' found.\n");
 846                 #endif
 847         } else {
 848                 #ifdef __MMFILE_TEST_MODE__
 849                 debug_msg ("'ID3' not found.\n");
 850                 #endif
 851                 goto search_end;
 852         }
 853
 854         /**@note weak id3v2 tag checking*/
 855         if (tagHeader[3] != 0xFF && tagHeader[4] != 0xFF &&
 856                 (tagHeader[6] & 0x80) == 0 && (tagHeader[7] & 0x80) == 0 &&
 857                 (tagHeader[8] & 0x80) == 0 && (tagHeader[9] & 0x80) == 0) {
 858                 #ifdef __MMFILE_TEST_MODE__
 859                 debug_msg ("good ID3V2 tag.\n");
 860                 #endif
 861         } else {
 862                 debug_warning ("It's bad ID3V2 tag.\n");
 863                 goto search_end;
 864         }
 865
 866         tagVersion = tagHeader[3];
 867
 868         if (tagVersion > 4) {
 869                 #ifdef __MMFILE_TEST_MODE__
 870                 debug_msg("Tag version not supported\n");
 871                 #endif
 872                 goto search_end;
 873         }
 874
 875         encSize = _MMFILE_GET_INT_NUMBER(&tagHeader[6]);
 876         tagInfoSize = _MMFILE_MP3_TAGV2_HEADER_LEN;
 877         tagInfoSize += (((encSize & 0x0000007F) >> 0) | ((encSize & 0x00007F00) >> 1) | ((encSize & 0x007F0000) >> 2) | ((encSize & 0x7F000000) >> 3));
 878
 879         /**@note unfortunately, some contents has many id3 tag.*/
 880         acc_tagsize += tagInfoSize;
 881         #ifdef __MMFILE_TEST_MODE__
 882         debug_msg("tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
 883         #endif
 884
 885         mmfile_seek(fp, acc_tagsize, MMFILE_SEEK_SET);
 886         *offset = acc_tagsize;
 887         goto _START_TAG_SEARCH;
 888
 889 search_end:
 890         return 1;
 891 }
 892
 893
 894
 895 /*
 896  *      This fuction retrieves the start position of header.
 897  *      Param   _pFile [in]     Specifies the file pointer of mp3 file.
 898  *      This function returns the start position of header.
 899  */
 900 static int
 901 __AvFindStartOfMp3Header(MMFileIOHandle *hFile,  unsigned char *buf, AvFileContentInfo* pInfo)
 902 {
 903         int             index=0;
 904         long    readLen;
 905         unsigned long   id3v2TagLen = 0;
 906         unsigned char   *pHeader = NULL;
 907         unsigned long  preHeaderGap = 0;
 908         unsigned long  frameLen = 0;
 909         unsigned long  nextFrameOff = 0;     /* Offset to the start of the next frame */
 910         unsigned long  nextFrameOffEnd = 0;
 911         unsigned long  bufLen = 0;
 912         bool bFoundSync = false;
 913         unsigned long  minLen;
 914
 915
 916
 917         if(pInfo->fileLen > (_AV_MP3_HEADER_POSITION_MAX+ pInfo->tagV2Info.tagLen))
 918                 bufLen = _AV_MP3_HEADER_POSITION_MAX;
 919         else
 920                 bufLen = pInfo ->fileLen - pInfo->tagV2Info.tagLen;
 921
 922         if(IS_ID3V2_TAG(buf))
 923         {
 924
 925
 926                 if(pInfo->tagV2Info.tagVersion == 0x02)
 927                 {
 928
 929                         if(!mm_file_id3tag_parse_v222(pInfo, buf))
 930                                 pInfo->tagV2Info.tagLen = 0;
 931                 }
 932                 else if (pInfo->tagV2Info.tagVersion == 0x03)
 933                 {
 934
 935                         if(!mm_file_id3tag_parse_v223(pInfo, buf))
 936                                 pInfo->tagV2Info.tagLen = 0;
 937                 }
 938                 else if (pInfo->tagV2Info.tagVersion == 0x04)
 939                 {
 940
 941                         if(!mm_file_id3tag_parse_v224(pInfo, buf)) // currently 2.4 ver pased by 2.3 routine
 942                                 pInfo->tagV2Info.tagLen = 0;
 943                 }
 944                 else
 945                 {
 946                         #ifdef __MMFILE_TEST_MODE__
 947                         debug_msg ( "pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagVersion);
 948                         #endif
 949                 }
 950
 951                 id3v2TagLen = pInfo->tagV2Info.tagLen;
 952
 953                 #ifdef __MMFILE_TEST_MODE__
 954                 debug_msg ( "id3v2TagLen(%d)\n", id3v2TagLen);
 955                 #endif
 956
 957                 if(id3v2TagLen)
 958                 {
 959                         if (mmfile_seek (hFile, id3v2TagLen, SEEK_SET) < 0) {
 960                                 debug_error ( "seek failed.\n");
 961                                 return -1;
 962                         }
 963                         if ((readLen = mmfile_read (hFile, buf, bufLen)) <= 0) {
 964                                 debug_error ( "seek failed.\n");
 965                                 return -1;
 966                         }
 967                 }
 968                 while(1)
 969                 {
 970                         if (preHeaderGap == bufLen -2)
 971                                 break;
 972                         if(__AvIsValidHeader(pInfo, buf+preHeaderGap))
 973                                 break;
 974                         preHeaderGap++;
 975                 }
 976
 977         }
 978         else
 979         {
 980                 while(1)
 981                 {
 982                         if (preHeaderGap == bufLen -2)
 983                                 break;
 984                         if(__AvIsValidHeader(pInfo, buf+preHeaderGap))
 985                                 break;
 986                         preHeaderGap++;
 987                 }
 988
 989         }
 990         minLen = 4;
 991
 992         buf += preHeaderGap;
 993         index += preHeaderGap;
 994         while (index <= (bufLen - minLen))
 995         {
 996                 if(buf[0] == 0xff)
 997                 {
 998                         if(VALID_SYNC(buf))
 999                         {
1000                                 if(bufLen - index > 256)
1001                                 {
1002                                         pHeader = mmfile_malloc (256);
1003                                         if (pHeader == NULL)
1004                                         {
1005                                                 debug_error ( "malloc failed.\n");
1006                                                 return -1;
1007                                         }
1008                                         strncpy((char *)pHeader, (char *)buf, 256);
1009                                 }
1010                                 else
1011                                 {
1012                                         debug_error ( "Header field is not exist\n");
1013                                         return -1;
1014                                 }
1015                                 if ( __AvParseMp3Header( pInfo, pHeader ) == false)
1016                                 {
1017                                         //return -1;
1018                                         if(pHeader)
1019                                                 _FREE_EX(pHeader);
1020                                         debug_warning ( "Mp3 parse header failed & index(%d)\n", index);
1021                                         buf++;
1022                                         index++;
1023                                         continue;
1024                                 }
1025                                 else
1026                                 {
1027                                         #ifdef __MMFILE_TEST_MODE__
1028                                         debug_msg ( "This header is valid. index(%d)\n", index);
1029                                         #endif
1030                                 }
1031
1032                                 if ( __AvParseXingHeader( pInfo, pHeader ) )
1033                                 {
1034                                         __AvGetXingBitrate( pInfo );
1035                                 }
1036                                 else if(__AvParseVBRIHeader( pInfo, pHeader ))
1037                                 {
1038                                         __AvGetVBRIBitrate( pInfo );
1039                                 }
1040
1041                                 if (pInfo->bVbr)
1042                                 {
1043                                         if(pHeader)
1044                                                 _FREE_EX(pHeader);
1045                                         bFoundSync = true;
1046                                         break;
1047                                 }
1048                                 else
1049                                 {
1050                                         if(__AvIsValidHeader(pInfo, pHeader))
1051                                         {
1052                                                 if(pHeader)
1053                                                         _FREE_EX(pHeader);
1054
1055                                                 __AvGetMp3FrameSize( pInfo );
1056                                                 pInfo->datafileLen = pInfo->fileLen - pInfo->headerPos;
1057                                                 frameLen = pInfo->frameSize;
1058                                                 if (frameLen)
1059                                                 {
1060                                                         #ifdef __MMFILE_TEST_MODE__
1061                                                         debug_msg ("<<< frameLen=[%d] >>> \n", frameLen);
1062                                                         #endif
1063
1064                                                         #ifndef __MMFILE_NEW_FRAME_FUNC // FIXME : what purpose to do this?
1065                                                         /* Account for loss of precision in the frame length calculation*/
1066                                                         frameLen--;
1067                                                         #endif
1068
1069                                                         /* Check if the remaining buffer size is large enough to
1070                                                         * look for another sync */
1071                                                         if ((index + frameLen) < (bufLen - (minLen - 1)))
1072                                                         {
1073                                                                 nextFrameOff = frameLen;
1074                                                                 nextFrameOffEnd = nextFrameOff +MIN(6, bufLen - (index+frameLen) - (minLen - 1));
1075
1076                                                                 /* Search the next few bytes for the next sync */
1077                                                                 while (nextFrameOff < nextFrameOffEnd)
1078                                                                 {
1079                                                                         if (VALID_SYNC(buf+nextFrameOff))
1080                                                                         {
1081                                                                                 if(IS_VALID_FRAME_MP3(buf+nextFrameOff))
1082                                                                                 {
1083                                                                                         bFoundSync = true;
1084                                                                                         break;
1085                                                                                 }
1086                                                                         }
1087                                                                         nextFrameOff++;
1088                                                                 }
1089                                                                 if (bFoundSync == true)
1090                                                                         break;
1091                                                         }
1092                                                         else
1093                                                         {
1094                                                                 /* Assume that the first sync is valid, since there is not
1095                                                                 * enough data in the buffer to look for the next sync */
1096                                                                 bFoundSync = true;
1097                                                         break;
1098                                                         }
1099                                                 }
1100
1101                                         }
1102                                         else
1103                                         {
1104                                                 debug_warning ( "Is not vaild header pHeader\n");
1105                                         }
1106                                 }
1107                                 if(pHeader)
1108                                         _FREE_EX(pHeader);
1109                         }
1110                         else
1111                         {
1112                                 debug_warning ( "Mp3 file frist byte is 0xff, but not header sync\n");
1113                         }
1114                 }
1115                 buf++;
1116                 index++;
1117         }
1118
1119         _FREE_EX (pHeader);
1120
1121         if (mmfile_seek(hFile, 0, SEEK_SET) < 0) {
1122                 debug_error ( "seek error!\n");
1123                 return -1;
1124         }
1125         if(index > (bufLen - minLen))
1126         {
1127                  debug_warning ( "Mp3 file sync is not found : index(%d) bufLen(%d), minLen(%d)\n", index, bufLen, minLen);
1128                 return -1;
1129         }
1130
1131         if(bFoundSync == true)
1132         {
1133                 #ifdef __MMFILE_TEST_MODE__
1134                 debug_msg ( "Mp3 file found a sync Success!\n");
1135                 #endif
1136         }
1137         else
1138         {
1139                 #ifdef __MMFILE_TEST_MODE__
1140                 debug_msg ( "Mp3 file found a sync Failed!\n");
1141                 #endif
1142                 return -1;
1143         }
1144
1145         return index+id3v2TagLen;
1146 }
1147
1148 /*
1149  *      This function retrieves the mp3 information.
1150  *      Param   szFileName [in] Specifies a mp3 file path.
1151  *      Param   _frame [out]    Specifies a struct pointer for mp3 information.
1152  *      This function returns true on success, or false on failure.
1153  */
1154 static int mmf_file_mp3_get_infomation (char *filename, AvFileContentInfo* pInfo )
1155 {
1156         MMFileIOHandle  *hFile;
1157         unsigned char   header[256];
1158         unsigned long   numOfFrames=0;
1159         unsigned long   frameSamples=0;
1160         unsigned char   *buf = NULL;
1161         unsigned char*  v2TagExistCheck = NULL;
1162         unsigned int            tempNumFrames = 0;
1163         int     readAmount = 0, readedDataLen = 0;
1164         unsigned long long      tempduration = 0;
1165         unsigned char   TagBuff[MP3TAGINFO_SIZE + TAGV1_SEEK_GAP];
1166         unsigned char           TagV1ID[4] = { 0x54, 0x41, 0x47}; //TAG
1167         int             tagHeaderPos = 0;
1168         int ret = 0;
1169         unsigned int head_offset = 0;
1170         debug_fenter();
1171
1172         if (pInfo == NULL || filename == NULL)
1173                 return -1;
1174
1175         memset( pInfo, 0x00, sizeof(AvFileContentInfo) );
1176
1177         pInfo->tagV2Info.tagLen = 0;
1178         pInfo->headerPos = 0;
1179         pInfo->genre = 148;
1180
1181         /*open*/
1182         ret = mmfile_open (&hFile, filename, MMFILE_RDONLY);
1183         if (ret == MMFILE_UTIL_FAIL)
1184         {
1185                 debug_error ( "open failed.\n");
1186                 return -1;
1187         }
1188
1189         mmfile_seek (hFile, 0L, SEEK_END);
1190         pInfo->fileLen = mmfile_tell (hFile);
1191         if (pInfo->fileLen <= 0)
1192         {
1193                 debug_error ( "file is too small.\n");
1194                 goto EXCEPTION;
1195         }
1196         mmfile_seek (hFile, 0L, SEEK_SET);
1197
1198         v2TagExistCheck = mmfile_malloc (MP3_TAGv2_HEADER_LEN);
1199         if (v2TagExistCheck == NULL) {
1200                 debug_error ( "malloc failed.\n");
1201                 goto EXCEPTION;
1202         }
1203
1204         if (mmfile_read (hFile, v2TagExistCheck, MP3_TAGv2_HEADER_LEN) > 0)
1205         {
1206                 if(IS_ID3V2_TAG(v2TagExistCheck))
1207                 {
1208                         if(!(v2TagExistCheck[3] == 0xFF || v2TagExistCheck[4] == 0xFF ||v2TagExistCheck[6] >= 0x80 || v2TagExistCheck[7] >= 0x80 || v2TagExistCheck[8] >= 0x80 || v2TagExistCheck[9] >= 0x80))
1209                         {
1210                                 if(!(v2TagExistCheck[3] > 0x04))
1211                                 {
1212                                         pInfo->tagV2Info.tagVersion = v2TagExistCheck[3];
1213                                         pInfo->tagV2Info.tagLen = MP3_TAGv2_HEADER_LEN;
1214                                         pInfo->tagV2Info.tagLen += (unsigned long)v2TagExistCheck[6] << 21 | (unsigned long)v2TagExistCheck[7] << 14 |(unsigned long)v2TagExistCheck[8] << 7  | (unsigned long)v2TagExistCheck[9];
1215                                         #ifdef __MMFILE_TEST_MODE__
1216                                         debug_msg ( "pInfo->tagV2Info.tagLen(%d), pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagLen, pInfo->tagV2Info.tagVersion);
1217                                         #endif
1218                                 }
1219                                 else
1220                                 {
1221                                         #ifdef __MMFILE_TEST_MODE__
1222                                         debug_msg ( "tag is a not supported version(%d)\n", v2TagExistCheck[3]);
1223                                         #endif
1224                                 }
1225                         }
1226                         else
1227                         {
1228                                 #ifdef __MMFILE_TEST_MODE__
1229                                 debug_msg ( "tag is a tag data is valid.\n");
1230                                 #endif
1231                         }
1232                 }
1233                 else
1234                 {
1235                         #ifdef __MMFILE_TEST_MODE__
1236                         debug_msg ( "this mp3 file is not included ID3v2 tag info!\n");
1237                         #endif
1238                 }
1239         }
1240         else
1241         {
1242                 debug_error ( "v2TagExistCheck value read fail!\n");
1243                 if(v2TagExistCheck)
1244                         _FREE_EX(v2TagExistCheck);
1245                 goto EXCEPTION;
1246         }
1247
1248         if(v2TagExistCheck)
1249                 _FREE_EX(v2TagExistCheck);
1250
1251         if(!(pInfo->fileLen > pInfo->tagV2Info.tagLen ))
1252                 pInfo->tagV2Info.tagLen = 0;
1253
1254         if (mmfile_seek(hFile, 0L, SEEK_SET) < 0)
1255                 goto EXCEPTION;
1256
1257         #ifdef __MMFILE_TEST_MODE__
1258         debug_msg ( "pInfo->fileLen(%lld)\n", pInfo->fileLen);
1259         #endif
1260
1261         if(pInfo->fileLen > (_AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen))
1262         {
1263                 readAmount = _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen;
1264                 buf = mmfile_malloc (readAmount);
1265                 if (buf == NULL) {
1266                         debug_error ( "malloc failed.\n");
1267                         goto EXCEPTION;
1268                 }
1269
1270                 while(readAmount > 0)
1271                 {
1272                         if(readAmount >= AV_MP3_HEADER_READ_MAX)
1273                         {
1274                                 if ((readedDataLen <= _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen)
1275                                         &&(mmfile_read(hFile, buf+readedDataLen, AV_MP3_HEADER_READ_MAX) <= 0))
1276                                 {
1277                                         if(buf)
1278                                                 _FREE_EX(buf);
1279
1280                                         goto EXCEPTION;
1281                                 }
1282                                 else
1283                                 {
1284                                         #ifdef __MMFILE_TEST_MODE__
1285                                         debug_msg ( "Reading buf readedDataLen(%d) readAmount (%d)\n", readedDataLen,readAmount);
1286                                         #endif
1287                                 }
1288                         }
1289                         else
1290                         {
1291                                 if ((readedDataLen <= _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen)
1292                                         &&(mmfile_read(hFile, buf+readedDataLen, readAmount) <= 0))
1293                                 {
1294                                         if(buf)
1295                                                 _FREE_EX(buf);
1296
1297                                         goto EXCEPTION;
1298                                 }
1299                                 else
1300                                 {
1301                                         #ifdef __MMFILE_TEST_MODE__
1302                                         debug_msg ( "The remained buf readed! readedDataLen(%d) readAmount (%d)\n", readedDataLen,readAmount);
1303                                         #endif
1304                                 }
1305                         }
1306
1307                         readAmount -= AV_MP3_HEADER_READ_MAX;
1308                         readedDataLen += AV_MP3_HEADER_READ_MAX;
1309
1310                         if(readAmount <= 0)
1311                                 break;
1312                 }
1313         }
1314         else
1315         {
1316                 buf = mmfile_malloc (pInfo->fileLen);
1317                 if (buf == NULL)
1318                 {
1319                          goto EXCEPTION;
1320                 }
1321
1322                 if (mmfile_read(hFile, buf, pInfo->fileLen) <= 0)
1323                 {
1324                         if(buf)
1325                                 _FREE_EX(buf);
1326                         goto EXCEPTION;
1327                 }
1328         }
1329
1330
1331         if (__AvGetLastID3offset (hFile, &head_offset)) {
1332                 #ifdef __MMFILE_TEST_MODE__
1333                 debug_msg ( "search start offset: %u\n", head_offset);
1334                 #endif
1335                 pInfo->tagV2Info.tagLen = head_offset;
1336         }
1337
1338         pInfo->headerPos = (long) __AvFindStartOfMp3Header(hFile, buf, pInfo);
1339
1340         #ifdef __MMFILE_TEST_MODE__
1341         debug_msg ( "Header Pos: %ld\n", pInfo->headerPos);
1342         #endif
1343
1344         if(buf)
1345                 _FREE_EX(buf);
1346
1347         if (pInfo->headerPos == -1)
1348                 goto EXCEPTION;
1349
1350         if (mmfile_seek(hFile, pInfo->headerPos, SEEK_SET) < 0)
1351                 goto EXCEPTION;
1352
1353         if (mmfile_read (hFile, header, 256) <= 0)
1354                 goto EXCEPTION;
1355
1356         if ( __AvParseMp3Header( pInfo, header ) == false)
1357                 goto EXCEPTION;
1358
1359         if ( __AvParseXingHeader( pInfo, header ) )
1360         {
1361                 __AvGetXingBitrate( pInfo );
1362         }
1363         else if(__AvParseVBRIHeader( pInfo, header ))
1364         {
1365                 __AvGetVBRIBitrate( pInfo );
1366         }
1367         else
1368         {
1369                 __AvGetMp3FrameSize( pInfo );
1370                 pInfo->datafileLen = pInfo->fileLen - pInfo->headerPos;
1371                 #ifdef __MMFILE_TEST_MODE__
1372                 debug_msg ( "Mp3 File FrameSize (%d) pInfo->headerPos(%d)\n", pInfo->frameSize,pInfo->headerPos);
1373                 #endif
1374         }
1375
1376         if (mmfile_seek (hFile, -(MP3TAGINFO_SIZE + TAGV1_SEEK_GAP), SEEK_END) < 0)
1377                 goto EXCEPTION;
1378
1379
1380         pInfo ->bV1tagFound = false;
1381
1382         if (mmfile_read (hFile, TagBuff, MP3TAGINFO_SIZE + TAGV1_SEEK_GAP) <= 0)
1383                 goto EXCEPTION;
1384
1385         if ((tagHeaderPos = __AvMemstr(TagBuff, TagV1ID, 3, TAGV1_SEEK_GAP+5)) >= 0)
1386         {
1387                 #ifdef __MMFILE_TEST_MODE__
1388                 debug_msg ( "Mp3 File Tag is existing\n");
1389                 #endif
1390
1391                 pInfo ->bV1tagFound = true;
1392                 memcpy(TagBuff, (TagBuff + tagHeaderPos), MP3TAGINFO_SIZE);
1393
1394                 if(!mm_file_id3tag_parse_v110(pInfo, TagBuff))
1395                         goto EXCEPTION;
1396         }
1397
1398         mm_file_id3tag_restore_content_info (pInfo);
1399
1400         if(pInfo->bVbr)
1401                 numOfFrames = pInfo->frameNum*10;
1402         else
1403         {
1404                 numOfFrames = ((pInfo->fileLen
1405                 -(pInfo->headerPos + (pInfo ->bV1tagFound ? MP3TAGINFO_SIZE : 0) ) )*10) / pInfo->frameSize;
1406         }
1407         tempNumFrames = (unsigned int)(numOfFrames/10);
1408
1409
1410
1411         if((numOfFrames - tempNumFrames * 10 ) > 5)
1412                 numOfFrames = (numOfFrames/10) + 1;
1413         else
1414                 numOfFrames = numOfFrames/10;
1415
1416
1417
1418         tempduration = (unsigned long long)(numOfFrames *1000);
1419
1420         if(pInfo->mpegVersion== 1)
1421         {
1422                 if(pInfo->layer== 1)
1423                         frameSamples = MPEG_1_SIZE_LAYER_1;
1424                 else
1425                         frameSamples = MPEG_1_SIZE_LAYER_2_3;
1426         }
1427         else
1428         {
1429                 if(pInfo->layer == 1)
1430                         frameSamples = MPEG_2_SIZE_LAYER_1;
1431                 else
1432                         frameSamples = MPEG_2_SIZE_LAYER_2_3;
1433         }
1434
1435         debug_msg("frameSamples : %d, tempduration : %ld", frameSamples, tempduration);
1436
1437         if(tempduration < (unsigned long long)pInfo->sampleRate)
1438         {
1439                 tempduration = (tempduration*frameSamples*10)/pInfo->sampleRate;
1440                 tempduration = (tempduration/10);
1441         }
1442         else
1443                 tempduration = (tempduration*frameSamples)/pInfo->sampleRate;
1444
1445         pInfo->duration = tempduration;
1446
1447         mmfile_close(hFile);
1448
1449         /*debug print*/
1450         #ifdef __MMFILE_TEST_MODE__
1451         debug_msg ( "Mp3 File pInfo->duration (%lld) \n", pInfo->duration);
1452         debug_msg ( "** MP3 **\n");
1453         debug_msg ( "Version    : %u\n", pInfo->mpegVersion);
1454         debug_msg ( "Layer      : %u\n", pInfo->layer);
1455         debug_msg ( "Channel idx: %u\n", pInfo->channelIndex);
1456         debug_msg ( "Is VBR     : %d\n", (pInfo->bVbr == true ? 1 : 0));
1457         debug_msg ( "Bitrate    : %u\n", pInfo->bitRate);
1458         debug_msg ( "SampleRate : %u\n", pInfo->sampleRate);
1459         debug_msg ( "Channels   : %u\n", pInfo->channels);
1460         debug_msg ( "**** Info #1 ****\n");
1461         debug_msg ( "Title       : %s\n", pInfo->pTitle);
1462         debug_msg ( "Artist      : %s\n", pInfo->pArtist);
1463         debug_msg ( "Album       : %s\n", pInfo->pAlbum);
1464         debug_msg ( "Year        : %s\n", pInfo->pYear);
1465         debug_msg ( "Comment     : %s\n", pInfo->pComment);
1466         debug_msg ( "TrackNum    : %s\n", pInfo->pTrackNum);
1467         debug_msg ( "Genre       : %s\n", pInfo->pGenre);
1468         debug_msg ( "**** Info #2 ****\n");
1469         debug_msg ( "Author      : %s\n", pInfo->pAuthor);
1470         debug_msg ( "Copyright   : %s\n", pInfo->pCopyright);
1471         debug_msg ( "Comment : %s\n", pInfo->pComment);
1472         debug_msg ( "Rating      : %s\n", pInfo->pRating);
1473         debug_msg ( "RecDate     : %s\n", pInfo->pRecDate);
1474         debug_msg ( "Encoded by  : %s\n", pInfo->pEncBy);
1475         debug_msg ( "URL         : %s\n", pInfo->pURL);
1476         debug_msg ( "Ori. Artist : %s\n", pInfo->pOriginArtist);
1477         debug_msg ( "Composer    : %s\n", pInfo->pComposer);
1478         debug_msg ( "Conductor   : %s\n", pInfo->pConductor);
1479         debug_msg ( "Artwork     : mime(%s) addr(%p) size(%d)\n", pInfo->imageInfo.imageMIMEType, pInfo->imageInfo.pImageBuf, pInfo->imageInfo.imageLen);
1480         debug_msg ( "UnsyncLyrics   : %s\n", pInfo->pUnsyncLyrics);
1481         debug_msg ( "SyncLyrics size  : %d\n", pInfo->syncLyricsNum);
1482
1483         #endif
1484
1485         return 0;
1486
1487 EXCEPTION:
1488         debug_error ("Error occured!\n");
1489         mmfile_close(hFile);
1490         return -1;
1491 }