$(top_builddir)/formats/ffmpeg/libmmfile_formats.la
endif
-
-libmmffile_la_CFLAGS += $(MMLOG_CFLAGS) -DMMF_LOG_OWNER=0x040 -DMMF_DEBUG_PREFIX=\"MMF-FILE\"
-libmmffile_la_LIBADD += $(MMLOG_LIBS)
-
+libmmffile_la_CFLAGS += $(DLOG_CFLAGS)
+libmmffile_la_LIBADD += $(DLOG_LIBS)
pcfiles = mm-fileinfo.pc
pkgconfigdir = $(libdir)/pkgconfig
#include "mm_file_codecs.h"
/* open functions list */
-int mmfile_codec_open_dummy (MMFileCodecContext *codecContext, MMFileCodecFrame *input);
+int mmfile_codec_open_dummy(MMFileCodecContext *codecContext, MMFileCodecFrame *input);
#ifdef __cplusplus
/* plugin manadatory API */
-int mmfile_codec_decode_dummy (MMFileCodecContext *codecContext, MMFileCodecFrame *output);
-int mmfile_codec_close_dummy (MMFileCodecContext *codecContext);
+int mmfile_codec_decode_dummy(MMFileCodecContext *codecContext, MMFileCodecFrame *output);
+int mmfile_codec_close_dummy(MMFileCodecContext *codecContext);
EXPORT_API
-int mmfile_codec_open_dummy (MMFileCodecContext *codecContext, MMFileCodecFrame *input)
+int mmfile_codec_open_dummy(MMFileCodecContext *codecContext, MMFileCodecFrame *input)
{
- debug_warning ("called mmfile_codec_open_dummy\n");
-
- codecContext->Decode = mmfile_codec_decode_dummy;
- codecContext->Close = mmfile_codec_close_dummy;
-
- return MMFILE_CODEC_SUCCESS;
+ debug_warning("called mmfile_codec_open_dummy\n");
+
+ codecContext->Decode = mmfile_codec_decode_dummy;
+ codecContext->Close = mmfile_codec_close_dummy;
+
+ return MMFILE_CODEC_SUCCESS;
}
EXPORT_API
-int mmfile_codec_decode_dummy (MMFileCodecContext *codecContext, MMFileCodecFrame *output)
+int mmfile_codec_decode_dummy(MMFileCodecContext *codecContext, MMFileCodecFrame *output)
{
- debug_warning ("called mmfile_codec_decode_dummy\n");
- return MMFILE_CODEC_SUCCESS;
+ debug_warning("called mmfile_codec_decode_dummy\n");
+ return MMFILE_CODEC_SUCCESS;
}
EXPORT_API
-int mmfile_codec_close_dummy (MMFileCodecContext *codecContext)
+int mmfile_codec_close_dummy(MMFileCodecContext *codecContext)
{
- debug_warning ("called mmfile_codec_close_dummy\n");
+ debug_warning("called mmfile_codec_close_dummy\n");
+
+ codecContext->Decode = NULL;
+ codecContext->Close = NULL;
- codecContext->Decode = NULL;
- codecContext->Close = NULL;
-
- return MMFILE_CODEC_SUCCESS;
+ return MMFILE_CODEC_SUCCESS;
}
#include "mm_file_codec_private.h"
int (*OpenVideoCodecFunc[MM_VIDEO_CODEC_NUM]) (MMFileCodecContext *codecContext, MMFileCodecFrame *input) = {
- mmfile_codec_open_dummy, /* NONE */
- mmfile_codec_open_dummy, /* WMV */
- mmfile_codec_open_dummy, /* H261 */
- mmfile_codec_open_dummy, /* H262 */
- mmfile_codec_open_dummy, /* H263 */
- mmfile_codec_open_dummy, /* H263V2 */
- mmfile_codec_open_dummy, /* H263V3 */
- mmfile_codec_open_dummy, /* H264 */
- mmfile_codec_open_dummy, /* H26L */
- mmfile_codec_open_dummy, /* MJPEG */
- mmfile_codec_open_dummy, /* MPEG1 */
- mmfile_codec_open_dummy, /* MPEG2 */
- mmfile_codec_open_dummy, /* MPEG4 */
- mmfile_codec_open_dummy, /* MPEG4_SIMPLE */
- mmfile_codec_open_dummy, /* MPEG4_ADV_SIMPE */
- mmfile_codec_open_dummy, /* MPEG4_MAIN */
- mmfile_codec_open_dummy, /* MPEG4_CORE */
- mmfile_codec_open_dummy, /* MPEG4_ACE */
- mmfile_codec_open_dummy, /* MPEG4_ARTS */
- mmfile_codec_open_dummy, /* MPEG4_AVC */
- mmfile_codec_open_dummy, /* REAL */
- mmfile_codec_open_dummy, /* VC1 */
- mmfile_codec_open_dummy, /* AVS */
- mmfile_codec_open_dummy, /* CINEPAK */
- mmfile_codec_open_dummy, /* INDEO */
- mmfile_codec_open_dummy, /* THEORA */
- mmfile_codec_open_dummy, /* DIVX */
- mmfile_codec_open_dummy, /* XVID */
+ mmfile_codec_open_dummy, /* NONE */
+ mmfile_codec_open_dummy, /* WMV */
+ mmfile_codec_open_dummy, /* H261 */
+ mmfile_codec_open_dummy, /* H262 */
+ mmfile_codec_open_dummy, /* H263 */
+ mmfile_codec_open_dummy, /* H263V2 */
+ mmfile_codec_open_dummy, /* H263V3 */
+ mmfile_codec_open_dummy, /* H264 */
+ mmfile_codec_open_dummy, /* H26L */
+ mmfile_codec_open_dummy, /* MJPEG */
+ mmfile_codec_open_dummy, /* MPEG1 */
+ mmfile_codec_open_dummy, /* MPEG2 */
+ mmfile_codec_open_dummy, /* MPEG4 */
+ mmfile_codec_open_dummy, /* MPEG4_SIMPLE */
+ mmfile_codec_open_dummy, /* MPEG4_ADV_SIMPE */
+ mmfile_codec_open_dummy, /* MPEG4_MAIN */
+ mmfile_codec_open_dummy, /* MPEG4_CORE */
+ mmfile_codec_open_dummy, /* MPEG4_ACE */
+ mmfile_codec_open_dummy, /* MPEG4_ARTS */
+ mmfile_codec_open_dummy, /* MPEG4_AVC */
+ mmfile_codec_open_dummy, /* REAL */
+ mmfile_codec_open_dummy, /* VC1 */
+ mmfile_codec_open_dummy, /* AVS */
+ mmfile_codec_open_dummy, /* CINEPAK */
+ mmfile_codec_open_dummy, /* INDEO */
+ mmfile_codec_open_dummy, /* THEORA */
+ mmfile_codec_open_dummy, /* DIVX */
+ mmfile_codec_open_dummy, /* XVID */
};
EXPORT_API
-int mmfile_codec_open (MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input)
+int mmfile_codec_open(MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input)
{
- MMFileCodecContext *codecObject = NULL;
- int ret = 0;
-
- if (codecId <= MM_VIDEO_CODEC_NONE || codecId >= MM_VIDEO_CODEC_NUM || MMFILE_VIDEO_DECODE != codecType || NULL == input)
- {
- debug_error ("error: invalid params\n");
- return MMFILE_CODEC_FAIL;
- }
-
- if (NULL == OpenVideoCodecFunc[codecId])
- {
- debug_error ("error: Not implemented \n");
- return MMFILE_CODEC_FAIL;
- }
-
- codecObject = mmfile_malloc (sizeof (MMFileCodecContext));
- if (NULL == codecObject)
- {
- debug_error ("error: mmfile_malloc fail for codecObject\n");
- return MMFILE_CODEC_FAIL;
- }
-
- *codecContext = codecObject;
-
- ret = OpenVideoCodecFunc[codecId](codecObject, input);
- if (MMFILE_CODEC_FAIL == ret)
- {
- debug_error ("error: init fail about video codec\n");
- ret = MMFILE_CODEC_FAIL;
- goto exception;
- }
-
- return MMFILE_CODEC_SUCCESS;
+ MMFileCodecContext *codecObject = NULL;
+ int ret = 0;
+
+ if (codecId <= MM_VIDEO_CODEC_NONE || codecId >= MM_VIDEO_CODEC_NUM || MMFILE_VIDEO_DECODE != codecType || NULL == input) {
+ debug_error("error: invalid params\n");
+ return MMFILE_CODEC_FAIL;
+ }
+
+ if (NULL == OpenVideoCodecFunc[codecId]) {
+ debug_error("error: Not implemented \n");
+ return MMFILE_CODEC_FAIL;
+ }
+
+ codecObject = mmfile_malloc(sizeof(MMFileCodecContext));
+ if (NULL == codecObject) {
+ debug_error("error: mmfile_malloc fail for codecObject\n");
+ return MMFILE_CODEC_FAIL;
+ }
+
+ *codecContext = codecObject;
+
+ ret = OpenVideoCodecFunc[codecId](codecObject, input);
+ if (MMFILE_CODEC_FAIL == ret) {
+ debug_error("error: init fail about video codec\n");
+ ret = MMFILE_CODEC_FAIL;
+ goto exception;
+ }
+
+ return MMFILE_CODEC_SUCCESS;
exception:
- if (codecObject) mmfile_free(codecObject);
-
- return ret;
+ if (codecObject) mmfile_free(codecObject);
+
+ return ret;
}
EXPORT_API
-int mmfile_codec_decode (MMFileCodecContext *codecContext, MMFileCodecFrame *output)
+int mmfile_codec_decode(MMFileCodecContext *codecContext, MMFileCodecFrame *output)
{
- if (NULL == codecContext || NULL == codecContext->Decode )
- {
- debug_error ("error: invalid params\n");
- return MMFILE_CODEC_FAIL;
- }
+ if (NULL == codecContext || NULL == codecContext->Decode) {
+ debug_error("error: invalid params\n");
+ return MMFILE_CODEC_FAIL;
+ }
- return codecContext->Decode (codecContext, output);
+ return codecContext->Decode(codecContext, output);
}
EXPORT_API
-int mmfile_codec_close (MMFileCodecContext *codecContext)
+int mmfile_codec_close(MMFileCodecContext *codecContext)
{
- if (NULL == codecContext || NULL == codecContext->Close)
- {
- debug_error ("error: invalid params\n");
- return MMFILE_CODEC_FAIL;
- }
-
- codecContext->Close (codecContext);
-
- if (codecContext->Decode) codecContext->Decode = NULL;
- if (codecContext->Close) codecContext->Close = NULL;
- if (codecContext->privateData) mmfile_free(codecContext->privateData);
- mmfile_free (codecContext);
-
- return MMFILE_CODEC_SUCCESS;
+ if (NULL == codecContext || NULL == codecContext->Close) {
+ debug_error("error: invalid params\n");
+ return MMFILE_CODEC_FAIL;
+ }
+
+ codecContext->Close(codecContext);
+
+ if (codecContext->Decode) codecContext->Decode = NULL;
+ if (codecContext->Close) codecContext->Close = NULL;
+ if (codecContext->privateData) mmfile_free(codecContext->privateData);
+ mmfile_free(codecContext);
+
+ return MMFILE_CODEC_SUCCESS;
}
#define MMFILE_AAC_PARSER_FAIL 0
typedef enum _mmfile_aac_profile_type {
- AAC_PROFILE_MAIN,
- AAC_PROFILE_LC,
- AAC_PROFILE_SSR,
- AAC_PROFILE_LTP,
- AAC_PROFILE_UNKNOWN
+ AAC_PROFILE_MAIN,
+ AAC_PROFILE_LC,
+ AAC_PROFILE_SSR,
+ AAC_PROFILE_LTP,
+ AAC_PROFILE_UNKNOWN
}TAacProfileType;
typedef void* MMFileAACHandle;
typedef struct _mmfileaacstreaminfo {
- unsigned int iseekable;
- long long duration;
- long long fileSize;
- unsigned int bitRate;
- unsigned int samplingRate;
- unsigned int frameRate;
- unsigned int numAudioChannels;
- unsigned int numTracks;
- TAacProfileType profileType;
+ unsigned int iseekable;
+ long long duration;
+ long long fileSize;
+ unsigned int bitRate;
+ unsigned int samplingRate;
+ unsigned int frameRate;
+ unsigned int numAudioChannels;
+ unsigned int numTracks;
+ TAacProfileType profileType;
} tMMFILE_AAC_STREAM_INFO;
typedef struct _mmfileaactaginfo {
- char *title;
- char *author;
- char *artist;
- char *album;
- char *album_artist;
- char *year;
- char *copyright;
- char *comment;
- char *genre;
- char *tracknum;
- char *composer;
- char *classification;
- char *rating;
- char *recordDate;
- char *conductor;
- char *artworkMime;
- char *artwork;
- unsigned int artworkSize;
+ char *title;
+ char *author;
+ char *artist;
+ char *album;
+ char *album_artist;
+ char *year;
+ char *copyright;
+ char *comment;
+ char *genre;
+ char *tracknum;
+ char *composer;
+ char *classification;
+ char *rating;
+ char *recordDate;
+ char *conductor;
+ char *artworkMime;
+ char *artwork;
+ unsigned int artworkSize;
} tMMFILE_AAC_TAG_INFO;
-int mmfile_aacparser_open (MMFileAACHandle *handle, const char *src);
-int mmfile_aacparser_get_stream_info (MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo);
-int mmfile_aacparser_get_tag_info (MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *info);
-int mmfile_aacparser_get_next_frame (MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo);
-int mmfile_aacparser_close (MMFileAACHandle handle);
+int mmfile_aacparser_open(MMFileAACHandle *handle, const char *src);
+int mmfile_aacparser_get_stream_info(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo);
+int mmfile_aacparser_get_tag_info(MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *info);
+int mmfile_aacparser_get_next_frame(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo);
+int mmfile_aacparser_close(MMFileAACHandle handle);
#ifdef __cplusplus
}
typedef void* MMFileAMRHandle;
typedef struct _mmfileamrstreaminfo {
- long long duration;
- long long fileSize;
- unsigned int bitRate;
- unsigned int samplingRate;
- unsigned int frameRate;
- unsigned int numAudioChannels;
- unsigned int numTracks;
+ long long duration;
+ long long fileSize;
+ unsigned int bitRate;
+ unsigned int samplingRate;
+ unsigned int frameRate;
+ unsigned int numAudioChannels;
+ unsigned int numTracks;
} tMMFILE_AMR_STREAM_INFO;
-int mmfile_amrparser_open (MMFileAMRHandle *handle, const char *src);
-int mmfile_amrparser_get_stream_info (MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo);
-int mmfile_amrparser_close (MMFileAMRHandle handle);
+int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *src);
+int mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo);
+int mmfile_amrparser_close(MMFileAMRHandle handle);
#ifdef __cplusplus
}
#define MPEG_2_SIZE_LAYER_2_3 (MPEG_1_SIZE_LAYER_2_3 / 2)
/* MP3 */
-#define MP3TAGINFO_SIZE 128 // file end 128 byte
+#define MP3TAGINFO_SIZE 128 /* file end 128 byte */
#define FRAMES_FLAG 0x0001
#define BYTES_FLAG 0x0002
#define TOC_FLAG 0x0004
#define AV_MP3HDR_EMPHASIS_M 0x03
#define AV_MP3HDR_EMPHASIS_SHIFT 0
-#define MASK_MPEG 0x18 // 00011000
-#define MASK_MPEG_25 0x00 // 00000000
-#define MASK_MPEG_2 0x10 // 00010000
-#define MASK_MPEG_1 0x18 // 00011000
+#define MASK_MPEG 0x18 /* 00011000 */
+#define MASK_MPEG_25 0x00 /* 00000000 */
+#define MASK_MPEG_2 0x10 /* 00010000 */
+#define MASK_MPEG_1 0x18 /* 00011000 */
-#define MASK_LAYER 0x06 // 00000110
-#define MASK_LAYER_3 0x02 // 00000010
-#define MASK_LAYER_2 0x04 // 00000100
-#define MASK_LAYER_1 0x06 // 00000110
+#define MASK_LAYER 0x06 /* 00000110 */
+#define MASK_LAYER_3 0x02 /* 00000010 */
+#define MASK_LAYER_2 0x04 /* 00000100 */
+#define MASK_LAYER_1 0x06 /* 00000110 */
-#define MASK_CHANNEL 0xC0 // 11000000
-#define MASK_CHANNEL_ST 0x00 // 00000000
-#define MASK_CHANNEL_JS 0x40 // 01000000
-#define MASK_CHANNEL_DC 0x80 // 10000000
-#define MASK_CHANNEL_MN 0xC0 // 11000000
+#define MASK_CHANNEL 0xC0 /* 11000000 */
+#define MASK_CHANNEL_ST 0x00 /* 00000000 */
+#define MASK_CHANNEL_JS 0x40 /* 01000000 */
+#define MASK_CHANNEL_DC 0x80 /* 10000000 */
+#define MASK_CHANNEL_MN 0xC0 /* 11000000 */
-#define MASK_SAMPLERATE 0x0C // 00001100
+#define MASK_SAMPLERATE 0x0C /* 00001100 */
-#define MASK_PADDING 0x02 // 00000010
+#define MASK_PADDING 0x02 /* 00000010 */
-#define _AV_MP3_HEADER_POSITION_MAX (50*1024) // mp3 header should be exist inside this size
-#define AV_MP3_HEADER_READ_MAX 200000 // mp3 header should be exist inside this size
+#define _AV_MP3_HEADER_POSITION_MAX (50*1024) /* mp3 header should be exist inside this size */
+#define AV_MP3_HEADER_READ_MAX 200000 /* mp3 header should be exist inside this size */
#define AV_WM_LOCALCODE_SIZE_MAX 2
/*
* Xing Header Information
*/
-typedef struct{
- int hId; // from MPEG header, 0=MPEG2, 1=MPEG1
- int sampRate; // determined from MPEG header
- int flags; // from Xing header data
- int frames; // total bit stream frames from Xing header data
- int bytes; // total bit stream bytes from Xing header data
- int vbrScale; // encoded vbr scale from Xing header data
- unsigned char *toc; // pointer to unsigned char toc_buffer[100]
- // may be NULL if toc not desired
+typedef struct {
+ int hId; /* from MPEG header, 0=MPEG2, 1=MPEG1 */
+ int sampRate; /* determined from MPEG header */
+ int flags; /* from Xing header data */
+ int frames; /* total bit stream frames from Xing header data */
+ int bytes; /* total bit stream bytes from Xing header data */
+ int vbrScale; /* encoded vbr scale from Xing header data */
+ unsigned char *toc; /* pointer to unsigned char toc_buffer[100] */
+ /* may be NULL if toc not desired */
} AvXHeadData;
-typedef struct{
- int hId; // from MPEG header, 0=MPEG2, 1=MPEG1
- int vID; // ver. ID
- int sampRate; // determined from MPEG header
- float delay; // delay
- int qualityIndicator; // qualityIndicator
- int bytes; // total bit stream bytes from Xing header data
- int frames; // total bit stream frames from Xing header data
- int numOfTOC; // numOfTOC
- int vbriScale; // encoded vbri scale from VBRI header data
- int sizePerTable; // encoded sizePerTable from VBRI header data
- int framesPerTable; //encoded framesPerTable from VBRI header data
- unsigned char *toc; // pointer to unsigned char toc_buffer[100]
- // may be NULL if toc not desired
+typedef struct {
+ int hId; /* from MPEG header, 0=MPEG2, 1=MPEG1 */
+ int vID; /* ver. ID */
+ int sampRate; /* determined from MPEG header */
+ float delay; /* delay */
+ int qualityIndicator; /* qualityIndicator */
+ int bytes; /* total bit stream bytes from Xing header data */
+ int frames; /* total bit stream frames from Xing header data */
+ int numOfTOC; /* numOfTOC */
+ int vbriScale; /* encoded vbri scale from VBRI header data */
+ int sizePerTable; /* encoded sizePerTable from VBRI header data */
+ int framesPerTable; /*encoded framesPerTable from VBRI header data */
+ unsigned char *toc; /* pointer to unsigned char toc_buffer[100] */
+ /* may be NULL if toc not desired */
} AvVBRIHeadData;
-typedef enum {
+typedef enum {
AV_MPEG_VER_RESERVED, /* Reserved */
AV_MPEG_VER_1, /* MPEG Version 1.0 */
AV_MPEG_VER_UNKNOWN /* Unable to determine version information */
} AvMp3VerEnumType;
-typedef enum {
+typedef enum {
AV_MP3_LAYER_RESERVED = 0, /* Reserved */
- AV_MPEG2_LAYER_AAC = AV_MP3_LAYER_RESERVED, /* MPEG2 AAC compression */
+ AV_MPEG2_LAYER_AAC = AV_MP3_LAYER_RESERVED, /* MPEG2 AAC compression */
AV_MP3_LAYER_1, /* MPEG Layer 1 compression */
AV_MP3_LAYER_2, /* MPEG Layer 2 compression */
AV_MP3_LAYER_3, /* MPEG Layer 3 compression */
AV_MP3_LAYER_UNKNOWN /* Unable to determine layer information */
-}AvMpegLayerEnumType;
+} AvMpegLayerEnumType;
-typedef enum {
+typedef enum {
AV_MP3_BITRATE_FREE = 0, /* Free bitrate (determined by software) */
AV_MP3_BITRATE_8K = 8, /* Fixed bitrates */
AV_MP3_BITRATE_16K = 16, /* */
} AvID3v2PictureType;
-#define MP3TAGINFO_SIZE 128 // file end 128 byte
+#define MP3TAGINFO_SIZE 128 /* file end 128 byte */
#define MP3_ID3_TITLE_LENGTH 30
#define MP3_ID3_ARTIST_LENGTH 30
#define MP3_ID3_ALBUM_LENGTH 30
int imgDesLen;
int imgMimetypeLen;
bool bURLInfo;
-
} AvTagVer2ImageInfo;
typedef struct{
} AvTagVer2AdditionalData;
-
-typedef struct
-{
+
+typedef struct {
int titleLen;
int artistLen;
int authorLen;
int copyrightLen;
- //int descriptionLen; /*ID3tag official tag name is "COMM" and meaning "Comment"*/
+ /*int descriptionLen;*/ /*ID3tag official tag name is "COMM" and meaning "Comment"*/
int commentLen;
int ratingLen;
int albumLen;
int genreLen;
int tracknumLen;
int recdateLen;
-
-// for PC Studio Podcast
+
+/* for PC Studio Podcast */
int contentGroupLen;
-
-// for ID3V2 Tag
+
+/* for ID3V2 Tag */
int encbyLen;
int urlLen;
int originartistLen;
int composerLen;
-// To send resolution info to appl from OEM
- int width;
+/* To send resolution info to appl from OEM */
+ int width;
int height;
-
+
unsigned int bitRate;
unsigned int sampleRate;
unsigned int channels;
-// unsigned long creationTime;
+/* unsigned long creationTime; */
unsigned long duration;
-// for mp3 Info
- char *pToc; // VBR�϶� SeekPosition�� ���ϱ� ���� TOC ���̺��� ������ ��� �ִ� char �迭 , 100 ����Ʈ ����
- unsigned int mpegVersion; // 1 : mpeg 1, 2 : mpeg 2, 3 : mpeg2.5
- unsigned int layer; // 1 : layer1, 2 : layer2, 3 : layer3
- unsigned int channelIndex; // 0 : stereo, 1 : joint_stereo, 2 : dual_channel, 3 : mono
+/* for mp3 Info */
+ char *pToc; /* VBR�϶� SeekPosition�� ���ϱ� ���� TOC ���̺��� ������ ��� �ִ� char �迭, 100 ����Ʈ ���� */
+ unsigned int mpegVersion; /* 1 : mpeg 1, 2 : mpeg 2, 3 : mpeg2.5 */
+ unsigned int layer; /* 1 : layer1, 2 : layer2, 3 : layer3 */
+ unsigned int channelIndex; /* 0 : stereo, 1 : joint_stereo, 2 : dual_channel, 3 : mono */
unsigned int objectType;
unsigned int headerType;
- long fileLen; // mp3 ������ ��ü ����
- long headerPos; // mp3 ����� ó������ ��Ÿ���� ��ġ
- long datafileLen; // ID3Tag���� �����ϰ� ���� mp3 frame���� ���� , VBR�϶� XHEADDATA �� bytes �� �ش��Ѵ�
- int frameSize; // mp3 frame �� ���� ũ��
- int frameNum; // mp3 ���Ͽ� �������� � ����ִ°�?
- bool bVbr; // VBR mp3?
- bool bPadding; // Padding?
+ long fileLen; /* mp3 ������ ��ü ���� */
+ long headerPos; /* mp3 ����� ó������ ��Ÿ���� ��ġ */
+ long datafileLen; /* ID3Tag���� �����ϰ� ���� mp3 frame���� ����, VBR�϶� XHEADDATA �� bytes �� �ش��Ѵ� */
+ int frameSize; /* mp3 frame �� ���� ũ�� */
+ int frameNum; /* mp3 ���Ͽ� �������� � ����ִ°�? */
+ bool bVbr; /* VBR mp3? */
+ bool bPadding; /* Padding? */
bool bV1tagFound;
- char *pTitle; //Title/songname/
- char *pArtist; //Lead performer(s)/Soloist(s),
- char *pAuthor; //Author
+ char *pTitle; /*Title/songname/ */
+ char *pArtist; /*Lead performer(s)/Soloist(s), */
+ char *pAuthor; /*Author */
char *pCopyright;
- //char *pDescription; /*ID3tag official tag name is "COMM" and meaning "Comment"*/
+ /*char *pDescription;*/ /*ID3tag official tag name is "COMM" and meaning "Comment"*/
char *pComment;
char *pRating;
- char *pAlbum; //Album/Movie/
+ char *pAlbum; /*Album/Movie/ */
char *pAlbum_Artist;
char *pYear;
- char *pGenre;
- char *pTrackNum; //Track number/Position in set
- char *pRecDate; //Recording dates
-
-// for PC Studio Podcast
+ char *pGenre;
+ char *pTrackNum; /*Track number/Position in set */
+ char *pRecDate; /*Recording dates */
+
+/* for PC Studio Podcast */
char *pContentGroup;
-// for ID3V2 Tag
- char *pEncBy; //Encoded by
- char *pURL; //User defined URL link frame for ID3V2 Tag
- char *pOriginArtist; //Original artist(s)/performer(s)
- char *pComposer; //Composer
- AvTagVer2ImageInfo imageInfo; //Album art attached feature
- AvTagVer2AdditionalData tagV2Info; //Needed data for ID3 tag parsing
+/* for ID3V2 Tag */
+ char *pEncBy; /*Encoded by */
+ char *pURL; /*User defined URL link frame for ID3V2 Tag */
+ char *pOriginArtist; /*Original artist(s)/performer(s) */
+ char *pComposer; /*Composer */
+ AvTagVer2ImageInfo imageInfo; /*Album art attached feature */
+ AvTagVer2AdditionalData tagV2Info; /*Needed data for ID3 tag parsing */
-// for DRM 2.0
+/* for DRM 2.0 */
char *pTransactionID;
-//for ID3V1 Tag
- unsigned char genre;
+/*for ID3V1 Tag */
+ unsigned char genre;
} AvFileContentInfo;
int height;
} AvExtraInfo;
-inline static void mm_file_free_AvFileContentInfo (AvFileContentInfo *pInfo)
+inline static void mm_file_free_AvFileContentInfo(AvFileContentInfo *pInfo)
{
if (pInfo) {
- if (pInfo->pToc) mmfile_free (pInfo->pToc);
- if (pInfo->pTitle) mmfile_free (pInfo->pTitle);
- if (pInfo->pArtist) mmfile_free (pInfo->pArtist);
- if (pInfo->pAuthor) mmfile_free (pInfo->pAuthor);
- if (pInfo->pCopyright) mmfile_free (pInfo->pCopyright);
- //if (pInfo->pDescription) mmfile_free (pInfo->pDescription);
- if (pInfo->pComment) mmfile_free (pInfo->pComment);
- if (pInfo->pRating) mmfile_free (pInfo->pRating);
- if (pInfo->pAlbum) mmfile_free (pInfo->pAlbum);
- if (pInfo->pAlbum_Artist) mmfile_free (pInfo->pAlbum_Artist);
- if (pInfo->pYear) mmfile_free (pInfo->pYear);
- if (pInfo->pGenre) mmfile_free (pInfo->pGenre);
- if (pInfo->pTrackNum) mmfile_free (pInfo->pTrackNum);
- if (pInfo->pRecDate) mmfile_free (pInfo->pRecDate);
-
- if (pInfo->pContentGroup) mmfile_free (pInfo->pContentGroup);
-
- if (pInfo->pEncBy) mmfile_free (pInfo->pEncBy);
- if (pInfo->pURL) mmfile_free (pInfo->pURL);
- if (pInfo->pOriginArtist) mmfile_free (pInfo->pOriginArtist);
- if (pInfo->pComposer) mmfile_free (pInfo->pComposer);
-
- if (pInfo->imageInfo.pImageBuf) mmfile_free (pInfo->imageInfo.pImageBuf);
-
- if (pInfo->pTransactionID) mmfile_free (pInfo->pTransactionID);
+ if (pInfo->pToc) mmfile_free(pInfo->pToc);
+ if (pInfo->pTitle) mmfile_free(pInfo->pTitle);
+ if (pInfo->pArtist) mmfile_free(pInfo->pArtist);
+ if (pInfo->pAuthor) mmfile_free(pInfo->pAuthor);
+ if (pInfo->pCopyright) mmfile_free(pInfo->pCopyright);
+ /*if (pInfo->pDescription) mmfile_free(pInfo->pDescription); */
+ if (pInfo->pComment) mmfile_free(pInfo->pComment);
+ if (pInfo->pRating) mmfile_free(pInfo->pRating);
+ if (pInfo->pAlbum) mmfile_free(pInfo->pAlbum);
+ if (pInfo->pAlbum_Artist) mmfile_free(pInfo->pAlbum_Artist);
+ if (pInfo->pYear) mmfile_free(pInfo->pYear);
+ if (pInfo->pGenre) mmfile_free(pInfo->pGenre);
+ if (pInfo->pTrackNum) mmfile_free(pInfo->pTrackNum);
+ if (pInfo->pRecDate) mmfile_free(pInfo->pRecDate);
+ if (pInfo->pContentGroup) mmfile_free(pInfo->pContentGroup);
+ if (pInfo->pEncBy) mmfile_free(pInfo->pEncBy);
+ if (pInfo->pURL) mmfile_free(pInfo->pURL);
+ if (pInfo->pOriginArtist) mmfile_free(pInfo->pOriginArtist);
+ if (pInfo->pComposer) mmfile_free(pInfo->pComposer);
+ if (pInfo->imageInfo.pImageBuf) mmfile_free(pInfo->imageInfo.pImageBuf);
+ if (pInfo->pTransactionID) mmfile_free(pInfo->pTransactionID);
}
}
-bool mm_file_id3tag_parse_v110 (AvFileContentInfo* pInfo, unsigned char *buffer); //20050401 Condol : for MP3 content Info.
-bool mm_file_id3tag_parse_v222 (AvFileContentInfo* pInfo, unsigned char *buffer);
-bool mm_file_id3tag_parse_v223 (AvFileContentInfo* pInfo, unsigned char *buffer);
-bool mm_file_id3tag_parse_v224 (AvFileContentInfo* pInfo, unsigned char *buffer);
-void mm_file_id3tag_restore_content_info (AvFileContentInfo* pInfo);
+bool mm_file_id3tag_parse_v110(AvFileContentInfo* pInfo, unsigned char *buffer); //20050401 Condol : for MP3 content Info.
+bool mm_file_id3tag_parse_v222(AvFileContentInfo* pInfo, unsigned char *buffer);
+bool mm_file_id3tag_parse_v223(AvFileContentInfo* pInfo, unsigned char *buffer);
+bool mm_file_id3tag_parse_v224(AvFileContentInfo* pInfo, unsigned char *buffer);
+void mm_file_id3tag_restore_content_info(AvFileContentInfo* pInfo);
#ifdef __cplusplus
}
extern "C" {
#endif
-typedef struct mmfileimelodytags
-{
- char *title;
- char *composer;
- int beat;
- char *copyright;
- char *comment;
+typedef struct mmfileimelodytags {
+ char *title;
+ char *composer;
+ int beat;
+ char *copyright;
+ char *comment;
} tMMFileImelodyTagInfo;
char *comment;
} MIDI_INFO_SIMPLE;
-MIDI_INFO_SIMPLE* mmfile_format_get_midi_infomation (char* uri);
-void mmfile_format_free_midi_infomation (MIDI_INFO_SIMPLE *info);
+MIDI_INFO_SIMPLE *mmfile_format_get_midi_infomation(char *uri);
+void mmfile_format_free_midi_infomation(MIDI_INFO_SIMPLE *info);
#ifdef __cplusplus
}
#include "mm_file_formats.h"
/* open functions list: the order of list depends on mm-types.h */
-int mmfile_format_open_dummy (MMFileFormatContext *fileContext);
-int mmfile_format_open_ffmpg (MMFileFormatContext *fileContext);
-int mmfile_format_open_mp3 (MMFileFormatContext *fileContext);
-//int mmfile_format_open_3gp (MMFileFormatContext *fileContext);
-//int mmfile_format_open_avi (MMFileFormatContext *fileContext);
-//int mmfile_format_open_asf (MMFileFormatContext *fileContext);
-int mmfile_format_open_mmf (MMFileFormatContext *fileContext);
-int mmfile_format_open_amr (MMFileFormatContext *fileContext);
-int mmfile_format_open_aac (MMFileFormatContext *fileContext);
-int mmfile_format_open_wav (MMFileFormatContext *fileContext);
-int mmfile_format_open_mid (MMFileFormatContext *fileContext);
-int mmfile_format_open_imy (MMFileFormatContext *fileContext);
+int mmfile_format_open_dummy(MMFileFormatContext *fileContext);
+int mmfile_format_open_ffmpg(MMFileFormatContext *fileContext);
+int mmfile_format_open_mp3(MMFileFormatContext *fileContext);
+/*int mmfile_format_open_3gp(MMFileFormatContext *fileContext); */
+/*int mmfile_format_open_avi(MMFileFormatContext *fileContext); */
+/*int mmfile_format_open_asf(MMFileFormatContext *fileContext); */
+int mmfile_format_open_mmf(MMFileFormatContext *fileContext);
+int mmfile_format_open_amr(MMFileFormatContext *fileContext);
+int mmfile_format_open_aac(MMFileFormatContext *fileContext);
+int mmfile_format_open_wav(MMFileFormatContext *fileContext);
+int mmfile_format_open_mid(MMFileFormatContext *fileContext);
+int mmfile_format_open_imy(MMFileFormatContext *fileContext);
#ifdef __cplusplus
#define MMFILE_ID3TAG_FAIL 0
#define MMFILE_ID3TAG_SUCCESS 1
-typedef void* MMFileID3TagHandle;
-
-typedef enum mmfileId3TagInfoVersion
-{
- MMFILE_ID3TAG_V1_0 = 0,
- MMFILE_ID3TAG_V1_1,
- MMFILE_ID3TAG_V2_0,
- MMFILE_ID3TAG_V2_2,
- MMFILE_ID3TAG_V2_3,
- MMFILE_ID3TAG_V2_4,
- MMFILE_ID3TAG_VMAX,
+typedef void *MMFileID3TagHandle;
+
+typedef enum mmfileId3TagInfoVersion {
+ MMFILE_ID3TAG_V1_0 = 0,
+ MMFILE_ID3TAG_V1_1,
+ MMFILE_ID3TAG_V2_0,
+ MMFILE_ID3TAG_V2_2,
+ MMFILE_ID3TAG_V2_3,
+ MMFILE_ID3TAG_V2_4,
+ MMFILE_ID3TAG_VMAX,
} eMMFileID3TagVersion;
-int MMFileID3V1TagFind (MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out);
-int MMFileID3V2TagFind (MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out);
+int MMFileID3V1TagFind(MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out);
+int MMFileID3V2TagFind(MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out);
#ifdef __cplusplus
}
extern "C" {
#endif
-typedef void* MMFileTagsHandle;
+typedef void *MMFileTagsHandle;
#define MMFILE_TAGS_SUCCESS 1
#define MMFILE_TAGS_FAIL 0
-typedef enum mmfiletagstype
-{
- MMFILE_TAG_ID3V1 = 0,
- MMFILE_TAG_ID3V2,
- MMFILE_TAG_MUSICAL_MATCH,
- MMFILE_TAG_LYRICS3,
- MMFILE_TAG_APE,
- MMFILE_TAG_MAX,
+typedef enum mmfiletagstype {
+ MMFILE_TAG_ID3V1 = 0,
+ MMFILE_TAG_ID3V2,
+ MMFILE_TAG_MUSICAL_MATCH,
+ MMFILE_TAG_LYRICS3,
+ MMFILE_TAG_APE,
+ MMFILE_TAG_MAX,
} eMMFileTagsType;
-typedef struct mmfileTags
-{
- eMMFileTagsType typeOfTag;
- unsigned char bAppendedTag;
- unsigned int version;
- unsigned int startOffset;
- unsigned int tagSize;
- unsigned int endOffset;
+typedef struct mmfileTags {
+ eMMFileTagsType typeOfTag;
+ unsigned char bAppendedTag;
+ unsigned int version;
+ unsigned int startOffset;
+ unsigned int tagSize;
+ unsigned int endOffset;
} tMMFileTags;
-int MMFileOpenTags (MMFileTagsHandle *tagsHandle, const char *uriName);
-int MMFileGetFirstTag (MMFileTagsHandle tagsHandle, tMMFileTags *out);
-int MMFileGetNextTag (MMFileTagsHandle tagsHandle, tMMFileTags *out);
-int MMFileTagsClose (MMFileTagsHandle tagsHandle);
+int MMFileOpenTags(MMFileTagsHandle *tagsHandle, const char *uriName);
+int MMFileGetFirstTag(MMFileTagsHandle tagsHandle, tMMFileTags *out);
+int MMFileGetNextTag(MMFileTagsHandle tagsHandle, tMMFileTags *out);
+int MMFileTagsClose(MMFileTagsHandle tagsHandle);
#ifdef __cplusplus
}
#include "mm_file_format_aac.h"
-// Internal Error Type
+/* Internal Error Type */
#define MMFILE_AAC_PARSER_FILE_END 2
-// Media specific definations
+/* Media specific definations */
#define MMFILE_AAC_ADIF_HEADER_MAX_SIZE 30
#define MMFILE_AAC_ADTS_HEADER_MAX_SIZE 7
#define AAC_ADTS_FRAME_LEN_OFFSET 30
#define IS_AAC_ADTS_HEADER(buff) (((buff)[0] == 0xff) && (((buff)[1] & 0xf0) == 0xf0))
-// Array to Number conversions
-#define GET_INT_NUMBER(buff) (int)( (((int)(buff)[0]) << 24) | \
+/* Array to Number conversions */
+#define GET_INT_NUMBER(buff) (int)((((int)(buff)[0]) << 24) | \
(((int)(buff)[1]) << 16) | \
(((int)(buff)[2]) << 8) | \
(((int)(buff)[3])))
-#define GET_SHORT_NUMBER(buff) (short)( ((short)(buff)[0] << 8) | \
- ((short)(buff)[1]) )
-
-
-
-typedef enum _mmfile_aac_format_type {
- AAC_FORMAT_ADIF,
- AAC_FORMAT_ADTS,
- AAC_FORMAT_UNKNOWN
-}TAacFormatType;
+#define GET_SHORT_NUMBER(buff) (short)(((short)(buff)[0] << 8) | \
+ ((short)(buff)[1]))
+
+
+
+typedef enum _mmfile_aac_format_type {
+ AAC_FORMAT_ADIF,
+ AAC_FORMAT_ADTS,
+ AAC_FORMAT_UNKNOWN
+} TAacFormatType;
typedef enum _mmfile_aac_bitstream_type {
- AAC_STREAM_CONSTANT,
- AAC_STREAM_VARIABLE
-}TAacStreamType;
+ AAC_STREAM_CONSTANT,
+ AAC_STREAM_VARIABLE
+} TAacStreamType;
typedef enum _mmfile_aac_mpeg_type {
- AAC_MPEG_4,
- AAC_MPEG_2
-}TAacMpegType;
+ AAC_MPEG_4,
+ AAC_MPEG_2
+} TAacMpegType;
typedef struct _mmfile_aac_handle {
- MMFileIOHandle* hFile;
- AvFileContentInfo id3Handle;
- unsigned int streamOffset;
- unsigned int tagOffset;
- char isTagPresent;
- unsigned int tagInfoSize;
- unsigned char tagVersion;
- TAacFormatType formatType;
- TAacStreamType streamType;
- TAacMpegType mpegType;
- tMMFILE_AAC_STREAM_INFO streamInfo;
- tMMFILE_AAC_TAG_INFO tagInfo;
-}tMMFILE_AAC_HANDLE;
+ MMFileIOHandle *hFile;
+ AvFileContentInfo id3Handle;
+ unsigned int streamOffset;
+ unsigned int tagOffset;
+ char isTagPresent;
+ unsigned int tagInfoSize;
+ unsigned char tagVersion;
+ TAacFormatType formatType;
+ TAacStreamType streamType;
+ TAacMpegType mpegType;
+ tMMFILE_AAC_STREAM_INFO streamInfo;
+ tMMFILE_AAC_TAG_INFO tagInfo;
+} tMMFILE_AAC_HANDLE;
/*Index table for Sampling frequency */
-const int Sampling_freq_table[16] = { 96000, 88200, 64000, 48000,
+const int Sampling_freq_table[16] = { 96000, 88200, 64000, 48000,
44100, 32000, 24000, 22050,
16000, 12000, 11025, 8000,
- 0, 0, 0, 0 };
-
-/* internal APIs */
-void _aac_init_handle(tMMFILE_AAC_HANDLE* privateData);
-int _search_id3tag(tMMFILE_AAC_HANDLE* pData);
-int _parse_id3_tag(tMMFILE_AAC_HANDLE* pData);
-int _get_range_bits_value (unsigned char* buff, int fieldOffset, int fieldSize);
-int _parse_aac_adif_header (tMMFILE_AAC_HANDLE* pData);
-int _get_next_adts_frame_length(tMMFILE_AAC_HANDLE* pData, int* frameLen);
-int _parse_aac_adts_header(tMMFILE_AAC_HANDLE* pData);
-
-
-void _aac_init_handle(tMMFILE_AAC_HANDLE* privateData)
+ 0, 0, 0, 0
+ };
+
+/* internal APIs */
+void _aac_init_handle(tMMFILE_AAC_HANDLE *privateData);
+int _search_id3tag(tMMFILE_AAC_HANDLE *pData);
+int _parse_id3_tag(tMMFILE_AAC_HANDLE *pData);
+int _get_range_bits_value(unsigned char *buff, int fieldOffset, int fieldSize);
+int _parse_aac_adif_header(tMMFILE_AAC_HANDLE *pData);
+int _get_next_adts_frame_length(tMMFILE_AAC_HANDLE *pData, int *frameLen);
+int _parse_aac_adts_header(tMMFILE_AAC_HANDLE *pData);
+
+
+void _aac_init_handle(tMMFILE_AAC_HANDLE *privateData)
{
- /* Default Initializations */
- privateData->streamOffset = 0;
- privateData->isTagPresent = FALSE;
- privateData->streamOffset = 0;
- privateData->tagOffset = 0;
-
- privateData->streamInfo.fileSize = 0;
- privateData->streamInfo.duration = 0;
- privateData->streamInfo.bitRate = 0;
- privateData->streamInfo.samplingRate = 0;
- privateData->streamInfo.frameRate = 0;
- privateData->streamInfo.numAudioChannels = 0;
- privateData->streamInfo.numTracks = 1;
- privateData->streamInfo.profileType = 0;
-
- privateData->tagInfo.title = NULL;
- privateData->tagInfo.author = NULL;
- privateData->tagInfo.artist = NULL;
- privateData->tagInfo.album = NULL;
- privateData->tagInfo.album_artist = NULL;
- privateData->tagInfo.year = NULL;
- privateData->tagInfo.copyright = NULL;
- privateData->tagInfo.comment = NULL;
- privateData->tagInfo.genre = NULL;
- privateData->tagInfo.composer = NULL;
- privateData->tagInfo.classification = NULL;
- privateData->tagInfo.rating = NULL;
- privateData->tagInfo.recordDate = NULL;
- privateData->tagInfo.conductor = NULL;
- privateData->tagInfo.artwork = NULL;
- privateData->tagInfo.artworkSize = 0;
- privateData->tagInfo.artworkMime = NULL;
+ /* Default Initializations */
+ privateData->streamOffset = 0;
+ privateData->isTagPresent = FALSE;
+ privateData->streamOffset = 0;
+ privateData->tagOffset = 0;
+
+ privateData->streamInfo.fileSize = 0;
+ privateData->streamInfo.duration = 0;
+ privateData->streamInfo.bitRate = 0;
+ privateData->streamInfo.samplingRate = 0;
+ privateData->streamInfo.frameRate = 0;
+ privateData->streamInfo.numAudioChannels = 0;
+ privateData->streamInfo.numTracks = 1;
+ privateData->streamInfo.profileType = 0;
+
+ privateData->tagInfo.title = NULL;
+ privateData->tagInfo.author = NULL;
+ privateData->tagInfo.artist = NULL;
+ privateData->tagInfo.album = NULL;
+ privateData->tagInfo.album_artist = NULL;
+ privateData->tagInfo.year = NULL;
+ privateData->tagInfo.copyright = NULL;
+ privateData->tagInfo.comment = NULL;
+ privateData->tagInfo.genre = NULL;
+ privateData->tagInfo.composer = NULL;
+ privateData->tagInfo.classification = NULL;
+ privateData->tagInfo.rating = NULL;
+ privateData->tagInfo.recordDate = NULL;
+ privateData->tagInfo.conductor = NULL;
+ privateData->tagInfo.artwork = NULL;
+ privateData->tagInfo.artworkSize = 0;
+ privateData->tagInfo.artworkMime = NULL;
}
-int _search_id3tag(tMMFILE_AAC_HANDLE* pData)
+int _search_id3tag(tMMFILE_AAC_HANDLE *pData)
{
- unsigned char tagHeader[MP3_TAGv2_HEADER_LEN] = {0,};
- int encSize = 0;
- int readed = 0;
-
- mmfile_seek(pData->hFile, 0, MMFILE_SEEK_SET);
- readed = mmfile_read (pData->hFile, tagHeader, MP3_TAGv2_HEADER_LEN);
- if (MP3_TAGv2_HEADER_LEN != readed) {
+ unsigned char tagHeader[MP3_TAGv2_HEADER_LEN] = {0, };
+ int encSize = 0;
+ int readed = 0;
+
+ mmfile_seek(pData->hFile, 0, MMFILE_SEEK_SET);
+ readed = mmfile_read(pData->hFile, tagHeader, MP3_TAGv2_HEADER_LEN);
+ if (MP3_TAGv2_HEADER_LEN != readed) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg("Read Fail");
+ debug_msg("Read Fail");
#endif
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- if (!IS_ID3V2_TAG(tagHeader)) {
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ if (!IS_ID3V2_TAG(tagHeader)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg("No ID3 Tag");
+ debug_msg("No ID3 Tag");
#endif
- goto search_end;
- }
+ goto search_end;
+ }
- if (tagHeader[3] == 0xFF || tagHeader[4] == 0xFF ||
- tagHeader[6] >= 0x80 || tagHeader[7] >= 0x80 ||
+ if (tagHeader[3] == 0xFF || tagHeader[4] == 0xFF ||
+ tagHeader[6] >= 0x80 || tagHeader[7] >= 0x80 ||
tagHeader[8] >= 0x80 || tagHeader[9] >= 0x80) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg("Read Fail");
+ debug_msg("Read Fail");
#endif
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- pData->tagVersion = tagHeader[3];
+ return MMFILE_AAC_PARSER_FAIL;
+ }
- if(pData->tagVersion > 4) {
+ pData->tagVersion = tagHeader[3];
+
+ if (pData->tagVersion > 4) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg("\nTag version not supported");
+ debug_msg("\nTag version not supported");
#endif
- return MMFILE_AAC_PARSER_FAIL;
- }
+ return MMFILE_AAC_PARSER_FAIL;
+ }
- encSize = GET_INT_NUMBER(&tagHeader[6]);
- pData->tagInfoSize = MP3_TAGv2_HEADER_LEN;
+ encSize = GET_INT_NUMBER(&tagHeader[6]);
+ pData->tagInfoSize = MP3_TAGv2_HEADER_LEN;
- pData->tagInfoSize += (((encSize & 0x0000007F) >> 0) | ((encSize & 0x00007F00) >> 1) | \
- ((encSize & 0x007F0000) >> 2) | ((encSize & 0x7F000000) >> 3));
+ pData->tagInfoSize += (((encSize & 0x0000007F) >> 0) | ((encSize & 0x00007F00) >> 1) | \
+ ((encSize & 0x007F0000) >> 2) | ((encSize & 0x7F000000) >> 3));
- if(pData->tagInfoSize > pData->streamInfo.fileSize) {
+ if (pData->tagInfoSize > pData->streamInfo.fileSize) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg("Invalid size");
+ debug_msg("Invalid size");
#endif
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- pData->isTagPresent = TRUE;
- pData->tagOffset = 0;
- pData->streamOffset = pData->tagInfoSize;
-
- /* Filling the information in id3Handle for tag parsing */
- pData->id3Handle.fileLen = pData->streamInfo.fileSize;
- pData->id3Handle.tagV2Info.tagLen = pData->tagInfoSize;
- pData->id3Handle.tagV2Info.tagVersion = pData->tagVersion;
- pData->id3Handle.tagV2Info.tagLen = pData->tagInfoSize;
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ pData->isTagPresent = TRUE;
+ pData->tagOffset = 0;
+ pData->streamOffset = pData->tagInfoSize;
+
+ /* Filling the information in id3Handle for tag parsing */
+ pData->id3Handle.fileLen = pData->streamInfo.fileSize;
+ pData->id3Handle.tagV2Info.tagLen = pData->tagInfoSize;
+ pData->id3Handle.tagV2Info.tagVersion = pData->tagVersion;
+ pData->id3Handle.tagV2Info.tagLen = pData->tagInfoSize;
search_end:
- return MMFILE_AAC_PARSER_SUCCESS;
+ return MMFILE_AAC_PARSER_SUCCESS;
}
-int _parse_id3_tag(tMMFILE_AAC_HANDLE* pData)
+int _parse_id3_tag(tMMFILE_AAC_HANDLE *pData)
{
- unsigned char* tagBuff = NULL;
- AvFileContentInfo* hTag = &pData->id3Handle;
- int ret = FALSE;
- int readed = 0;
-
- mmfile_seek(pData->hFile, pData->tagOffset, MMFILE_SEEK_SET);
- tagBuff = (unsigned char*) mmfile_malloc(hTag->fileLen);
- if(tagBuff == NULL) {
- ret = MMFILE_AAC_PARSER_FAIL;
- debug_error ("failed to memory allocation. %d\n", hTag->fileLen);
- goto failure;
- }
-
- readed = mmfile_read(pData->hFile, tagBuff, hTag->fileLen);
- if (readed != hTag->fileLen) {
- debug_error ("failed to read. %d, %lld\n", readed, hTag->fileLen);
- goto failure;
- }
-
- switch(hTag->tagV2Info.tagVersion) {
- case 1:
- ret = mm_file_id3tag_parse_v110(hTag, tagBuff);
- break;
- case 2:
- ret = mm_file_id3tag_parse_v222(hTag, tagBuff);
- break;
- case 3:
- ret = mm_file_id3tag_parse_v223(hTag, tagBuff);
- break;
- case 4:
- ret = mm_file_id3tag_parse_v224(hTag, tagBuff);
- break;
- default:
- debug_error ("Invalid Tag version [%d]\n", hTag->tagV2Info.tagVersion);
- break;
- }
-
- if(ret == FALSE) {
- ret = MMFILE_AAC_PARSER_FAIL;
- debug_warning ("failed to parse\n");
- goto failure;
- }
-
- mm_file_id3tag_restore_content_info(hTag);
-
- pData->tagInfo.title = hTag->pTitle;
- pData->tagInfo.author = hTag->pAuthor;
- pData->tagInfo.artist = hTag->pArtist;
- pData->tagInfo.album = hTag->pAlbum;
- pData->tagInfo.album_artist = hTag->pAlbum_Artist;
- pData->tagInfo.year = hTag->pYear;
- pData->tagInfo.copyright = hTag->pCopyright;
- pData->tagInfo.comment = hTag->pComment;
- pData->tagInfo.genre = hTag->pGenre;
- pData->tagInfo.tracknum = hTag->pTrackNum;
- pData->tagInfo.composer = hTag->pComposer;
- pData->tagInfo.classification = hTag->pContentGroup;
- pData->tagInfo.rating = hTag->pRating;
- pData->tagInfo.recordDate = hTag->pRecDate;
- pData->tagInfo.conductor = hTag->pConductor;
- pData->tagInfo.artworkMime = hTag->imageInfo.imageMIMEType;
- pData->tagInfo.artworkSize = hTag->imageInfo.imageLen;
- pData->tagInfo.artwork = hTag->imageInfo.pImageBuf;
-
- ret = MMFILE_AAC_PARSER_SUCCESS;
+ unsigned char *tagBuff = NULL;
+ AvFileContentInfo *hTag = &pData->id3Handle;
+ int ret = FALSE;
+ int readed = 0;
+
+ mmfile_seek(pData->hFile, pData->tagOffset, MMFILE_SEEK_SET);
+ tagBuff = (unsigned char *) mmfile_malloc(hTag->fileLen);
+ if (tagBuff == NULL) {
+ ret = MMFILE_AAC_PARSER_FAIL;
+ debug_error("failed to memory allocation. %d\n", hTag->fileLen);
+ goto failure;
+ }
+
+ readed = mmfile_read(pData->hFile, tagBuff, hTag->fileLen);
+ if (readed != hTag->fileLen) {
+ debug_error("failed to read. %d, %lld\n", readed, hTag->fileLen);
+ goto failure;
+ }
+
+ switch (hTag->tagV2Info.tagVersion) {
+ case 1:
+ ret = mm_file_id3tag_parse_v110(hTag, tagBuff);
+ break;
+ case 2:
+ ret = mm_file_id3tag_parse_v222(hTag, tagBuff);
+ break;
+ case 3:
+ ret = mm_file_id3tag_parse_v223(hTag, tagBuff);
+ break;
+ case 4:
+ ret = mm_file_id3tag_parse_v224(hTag, tagBuff);
+ break;
+ default:
+ debug_error("Invalid Tag version [%d]\n", hTag->tagV2Info.tagVersion);
+ break;
+ }
+
+ if (ret == FALSE) {
+ ret = MMFILE_AAC_PARSER_FAIL;
+ debug_warning("failed to parse\n");
+ goto failure;
+ }
+
+ mm_file_id3tag_restore_content_info(hTag);
+
+ pData->tagInfo.title = hTag->pTitle;
+ pData->tagInfo.author = hTag->pAuthor;
+ pData->tagInfo.artist = hTag->pArtist;
+ pData->tagInfo.album = hTag->pAlbum;
+ pData->tagInfo.album_artist = hTag->pAlbum_Artist;
+ pData->tagInfo.year = hTag->pYear;
+ pData->tagInfo.copyright = hTag->pCopyright;
+ pData->tagInfo.comment = hTag->pComment;
+ pData->tagInfo.genre = hTag->pGenre;
+ pData->tagInfo.tracknum = hTag->pTrackNum;
+ pData->tagInfo.composer = hTag->pComposer;
+ pData->tagInfo.classification = hTag->pContentGroup;
+ pData->tagInfo.rating = hTag->pRating;
+ pData->tagInfo.recordDate = hTag->pRecDate;
+ pData->tagInfo.conductor = hTag->pConductor;
+ pData->tagInfo.artworkMime = hTag->imageInfo.imageMIMEType;
+ pData->tagInfo.artworkSize = hTag->imageInfo.imageLen;
+ pData->tagInfo.artwork = hTag->imageInfo.pImageBuf;
+
+ ret = MMFILE_AAC_PARSER_SUCCESS;
failure:
- if(tagBuff) {
- mmfile_free(tagBuff);
- tagBuff = NULL;
- }
+ if (tagBuff) {
+ mmfile_free(tagBuff);
+ tagBuff = NULL;
+ }
- return ret;
+ return ret;
}
-int _get_range_bits_value (unsigned char* buff, int fieldOffset, int fieldSize)
+int _get_range_bits_value(unsigned char *buff, int fieldOffset, int fieldSize)
{
- int pos = 0;
- unsigned int srcByteStartOff = 0;
- unsigned int srcByteEndOff = 0;
- unsigned int srcBitStartOff = 0;
- unsigned int srcBitEndOff = 0;
- unsigned char dest[4] = {0,};
- unsigned int res = 0;
- unsigned int i,j, temp;
- unsigned char extraByteFlag = 0;
- unsigned int occupiedBytes = 0;
- unsigned char mask = 0, maskBit = 0x01;
-
-
- srcByteStartOff = (fieldOffset / 8);
- srcBitStartOff = (fieldOffset % 8);
-
- srcByteEndOff = ((fieldOffset + fieldSize - 1) / 8);
- srcBitEndOff = ((fieldOffset + fieldSize - 1) % 8);
-
- occupiedBytes = srcByteEndOff - srcByteStartOff + 1;
-
- for(i = srcByteStartOff, j = 0; i <= srcByteEndOff && j <= 3; i++,j++) {
- dest[j] = buff[i];
- }
-
- for(pos = 7; pos>= (char)srcBitStartOff; pos--) {
- mask = mask | maskBit;
- maskBit <<= 1;
- }
-
- dest[0] = dest[0] & mask;
-
- if(i <= srcByteEndOff) {
- extraByteFlag = 1;
- }
-
- res = GET_INT_NUMBER(dest);
-
- if(!extraByteFlag) {
- temp = (4 - occupiedBytes) * 8 + (7 - srcBitEndOff);
- res >>= temp;
- }
-
- if(extraByteFlag) {
- res <<= srcBitStartOff;
- temp = buff[srcByteEndOff] >> (7 - srcBitEndOff);
- res = res | (unsigned int)temp;
- }
-
- return res;
+ int pos = 0;
+ unsigned int srcByteStartOff = 0;
+ unsigned int srcByteEndOff = 0;
+ unsigned int srcBitStartOff = 0;
+ unsigned int srcBitEndOff = 0;
+ unsigned char dest[4] = {0, };
+ unsigned int res = 0;
+ unsigned int i, j, temp;
+ unsigned char extraByteFlag = 0;
+ unsigned int occupiedBytes = 0;
+ unsigned char mask = 0, maskBit = 0x01;
+
+
+ srcByteStartOff = (fieldOffset / 8);
+ srcBitStartOff = (fieldOffset % 8);
+
+ srcByteEndOff = ((fieldOffset + fieldSize - 1) / 8);
+ srcBitEndOff = ((fieldOffset + fieldSize - 1) % 8);
+
+ occupiedBytes = srcByteEndOff - srcByteStartOff + 1;
+
+ for (i = srcByteStartOff, j = 0; i <= srcByteEndOff && j <= 3; i++, j++) {
+ dest[j] = buff[i];
+ }
+
+ for (pos = 7; pos >= (char)srcBitStartOff; pos--) {
+ mask = mask | maskBit;
+ maskBit <<= 1;
+ }
+
+ dest[0] = dest[0] & mask;
+
+ if (i <= srcByteEndOff) {
+ extraByteFlag = 1;
+ }
+
+ res = GET_INT_NUMBER(dest);
+
+ if (!extraByteFlag) {
+ temp = (4 - occupiedBytes) * 8 + (7 - srcBitEndOff);
+ res >>= temp;
+ }
+
+ if (extraByteFlag) {
+ res <<= srcBitStartOff;
+ temp = buff[srcByteEndOff] >> (7 - srcBitEndOff);
+ res = res | (unsigned int)temp;
+ }
+
+ return res;
}
-int _parse_aac_adif_header (tMMFILE_AAC_HANDLE* pData)
+int _parse_aac_adif_header(tMMFILE_AAC_HANDLE *pData)
{
- unsigned char adifHeader[MMFILE_AAC_ADIF_HEADER_MAX_SIZE] = {0,};
- int currentBitOffset = 0;
- unsigned int fieldValue = 0;
- int copyRightStatus = 0;
- int readed = 0;
-
- mmfile_seek(pData->hFile, pData->streamOffset, MMFILE_SEEK_SET);
- readed = mmfile_read(pData->hFile, adifHeader, MMFILE_AAC_ADIF_HEADER_MAX_SIZE);
- if (readed < 0) {
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- if(memcmp(adifHeader, "ADIF", 4) != 0) {
- return MMFILE_AAC_PARSER_FAIL;
- }
- currentBitOffset += 32;
-
- copyRightStatus = _get_range_bits_value(adifHeader, currentBitOffset, 1);
- currentBitOffset += 1;
-
- if(copyRightStatus) {
- //skipping Copyright info
- currentBitOffset += 72;
- }
-
- //Original/copy
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 1);
- currentBitOffset += 1;
-
- //skipping Home status
- currentBitOffset += 1;
-
- //Bit stream type
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 1);
- currentBitOffset += 1;
- if(!fieldValue) {
- pData->streamType = AAC_STREAM_CONSTANT;
- }
- else {
- pData->streamType = AAC_STREAM_VARIABLE;
- }
-
- //Bit-rate
- pData->streamInfo.bitRate = _get_range_bits_value(adifHeader, currentBitOffset, 23);
- currentBitOffset += 23;
-
- //Num of program config elements
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 4);
- currentBitOffset += 4;
-
- //skipping adif buffer fullness
- currentBitOffset += 20;
-
- //skipping element instance tag
- currentBitOffset += 4;
-
- //Profile
- pData->streamInfo.profileType = _get_range_bits_value(adifHeader, currentBitOffset, 2);
- currentBitOffset += 2;
-
- //sampling freq index
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 4);
- currentBitOffset += 4;
- pData->streamInfo.samplingRate = Sampling_freq_table[fieldValue];
-
- //num_front_channel_elements
- pData->streamInfo.numAudioChannels = _get_range_bits_value(adifHeader, currentBitOffset, 4);
- currentBitOffset += 4;
-
- //num_side_channel_elements
- pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 4);
- currentBitOffset += 4;
-
- //num_back_channel_elements
- pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 4);
- currentBitOffset += 4;
-
- //num_lfe_channel_elements
- pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 2);
- currentBitOffset += 2;
-
- return MMFILE_AAC_PARSER_SUCCESS;
-
+ unsigned char adifHeader[MMFILE_AAC_ADIF_HEADER_MAX_SIZE] = {0, };
+ int currentBitOffset = 0;
+ unsigned int fieldValue = 0;
+ int copyRightStatus = 0;
+ int readed = 0;
+
+ mmfile_seek(pData->hFile, pData->streamOffset, MMFILE_SEEK_SET);
+ readed = mmfile_read(pData->hFile, adifHeader, MMFILE_AAC_ADIF_HEADER_MAX_SIZE);
+ if (readed < 0) {
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ if (memcmp(adifHeader, "ADIF", 4) != 0) {
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+ currentBitOffset += 32;
+
+ copyRightStatus = _get_range_bits_value(adifHeader, currentBitOffset, 1);
+ currentBitOffset += 1;
+
+ if (copyRightStatus) {
+ /*skipping Copyright info */
+ currentBitOffset += 72;
+ }
+
+ /*Original/copy */
+ fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 1);
+ currentBitOffset += 1;
+
+ /*skipping Home status */
+ currentBitOffset += 1;
+
+ /*Bit stream type */
+ fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 1);
+ currentBitOffset += 1;
+ if (!fieldValue) {
+ pData->streamType = AAC_STREAM_CONSTANT;
+ } else {
+ pData->streamType = AAC_STREAM_VARIABLE;
+ }
+
+ /*Bit-rate */
+ pData->streamInfo.bitRate = _get_range_bits_value(adifHeader, currentBitOffset, 23);
+ currentBitOffset += 23;
+
+ /*Num of program config elements */
+ fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ currentBitOffset += 4;
+
+ /*skipping adif buffer fullness */
+ currentBitOffset += 20;
+
+ /*skipping element instance tag */
+ currentBitOffset += 4;
+
+ /*Profile */
+ pData->streamInfo.profileType = _get_range_bits_value(adifHeader, currentBitOffset, 2);
+ currentBitOffset += 2;
+
+ /*sampling freq index */
+ fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ currentBitOffset += 4;
+ pData->streamInfo.samplingRate = Sampling_freq_table[fieldValue];
+
+ /*num_front_channel_elements */
+ pData->streamInfo.numAudioChannels = _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ currentBitOffset += 4;
+
+ /*num_side_channel_elements */
+ pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ currentBitOffset += 4;
+
+ /*num_back_channel_elements */
+ pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ currentBitOffset += 4;
+
+ /*num_lfe_channel_elements */
+ pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 2);
+ currentBitOffset += 2;
+
+ return MMFILE_AAC_PARSER_SUCCESS;
+
}
-int _parse_aac_adts_header(tMMFILE_AAC_HANDLE* pData)
+int _parse_aac_adts_header(tMMFILE_AAC_HANDLE *pData)
{
- unsigned char adtsHeader[MMFILE_AAC_ADTS_HEADER_MAX_SIZE] = {0,};
- int currentBitOffset = 0;
- unsigned int fieldValue = 0;
- int readed = 0;
-
- mmfile_seek(pData->hFile, pData->streamOffset, MMFILE_SEEK_SET);
- readed = mmfile_read(pData->hFile, adtsHeader, MMFILE_AAC_ADTS_HEADER_MAX_SIZE);
- if (readed < 0) {
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- if(!IS_AAC_ADTS_HEADER(adtsHeader)) {
- return MMFILE_AAC_PARSER_FAIL;
- }
- currentBitOffset += 12;
-
- //adtsId
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
- currentBitOffset += 1;
- pData->mpegType = (fieldValue != 0);
-
- //LayerType
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 2);
- currentBitOffset += 2;
-
- //skipping Protection Absent
- currentBitOffset += 1;
-
- //ProfileType
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 2);
- currentBitOffset += 2;
- pData->streamInfo.profileType = fieldValue;
-
- //SamplingrateIndex
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 4);
- currentBitOffset += 4;
- pData->streamInfo.samplingRate = Sampling_freq_table[fieldValue];
-
- //skipping PrivateBit
- currentBitOffset += 1;
-
- //ChannelConfig
- pData->streamInfo.numAudioChannels = _get_range_bits_value(adtsHeader, currentBitOffset, 3);
- currentBitOffset += 3;
-
- //Original/copy status
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
- currentBitOffset += 1;
-
- //skipping Home status
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
- currentBitOffset += 1;
-
- //copy right Id status bit
- currentBitOffset += 1;
-
- return MMFILE_AAC_PARSER_SUCCESS;
+ unsigned char adtsHeader[MMFILE_AAC_ADTS_HEADER_MAX_SIZE] = {0, };
+ int currentBitOffset = 0;
+ unsigned int fieldValue = 0;
+ int readed = 0;
+
+ mmfile_seek(pData->hFile, pData->streamOffset, MMFILE_SEEK_SET);
+ readed = mmfile_read(pData->hFile, adtsHeader, MMFILE_AAC_ADTS_HEADER_MAX_SIZE);
+ if (readed < 0) {
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ if (!IS_AAC_ADTS_HEADER(adtsHeader)) {
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+ currentBitOffset += 12;
+
+ /*adtsId */
+ fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
+ currentBitOffset += 1;
+ pData->mpegType = (fieldValue != 0);
+
+ /*LayerType */
+ fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 2);
+ currentBitOffset += 2;
+
+ /*skipping Protection Absent */
+ currentBitOffset += 1;
+
+ /*ProfileType */
+ fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 2);
+ currentBitOffset += 2;
+ pData->streamInfo.profileType = fieldValue;
+
+ /*SamplingrateIndex */
+ fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 4);
+ currentBitOffset += 4;
+ pData->streamInfo.samplingRate = Sampling_freq_table[fieldValue];
+
+ /*skipping PrivateBit */
+ currentBitOffset += 1;
+
+ /*ChannelConfig */
+ pData->streamInfo.numAudioChannels = _get_range_bits_value(adtsHeader, currentBitOffset, 3);
+ currentBitOffset += 3;
+
+ /*Original/copy status */
+ fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
+ currentBitOffset += 1;
+
+ /*skipping Home status */
+ fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
+ currentBitOffset += 1;
+
+ /*copy right Id status bit */
+ currentBitOffset += 1;
+
+ return MMFILE_AAC_PARSER_SUCCESS;
}
-int _get_next_adts_frame_length(tMMFILE_AAC_HANDLE* pData, int* frameLen)
+int _get_next_adts_frame_length(tMMFILE_AAC_HANDLE *pData, int *frameLen)
{
- unsigned char adtsHeader[MMFILE_AAC_ADTS_HEADER_MAX_SIZE] = {0,};
- int ret = MMFILE_AAC_PARSER_SUCCESS;
- long long filePosBefore = mmfile_tell(pData->hFile);
- int readed = 0;
+ unsigned char adtsHeader[MMFILE_AAC_ADTS_HEADER_MAX_SIZE] = {0, };
+ int ret = MMFILE_AAC_PARSER_SUCCESS;
+ long long filePosBefore = mmfile_tell(pData->hFile);
+ int readed = 0;
+
+ readed = mmfile_read(pData->hFile, adtsHeader, MMFILE_AAC_ADTS_HEADER_MAX_SIZE);
+ if (readed < 0)
+ return MMFILE_AAC_PARSER_FAIL;
- readed = mmfile_read(pData->hFile, adtsHeader, MMFILE_AAC_ADTS_HEADER_MAX_SIZE);
- if (readed < 0)
- return MMFILE_AAC_PARSER_FAIL;
-
#ifdef __MMFILE_TEST_MODE__
- debug_msg("\nFILE POS: %lld\n", filePosBefore);
- debug_msg("\nADTS HEADER: [%2x] [%2x] [%2x] [%2x] [%2x] [%2x]\n",
- adtsHeader[0], adtsHeader[1], adtsHeader[2], adtsHeader[3], adtsHeader[4], adtsHeader[5]);
+ debug_msg("\nFILE POS: %lld\n", filePosBefore);
+ debug_msg("\nADTS HEADER: [%2x] [%2x] [%2x] [%2x] [%2x] [%2x]\n",
+ adtsHeader[0], adtsHeader[1], adtsHeader[2], adtsHeader[3], adtsHeader[4], adtsHeader[5]);
#endif
-
- if(mmfile_tell(pData->hFile) >= pData->streamInfo.fileSize) {
- *frameLen = 0;
- ret = MMFILE_AAC_PARSER_FILE_END;
- goto function_end;
- }
-
- if(!IS_AAC_ADTS_HEADER(adtsHeader)) {
- *frameLen = 0;
- ret = MMFILE_AAC_PARSER_FAIL;
- goto function_end;
- }
-
- *frameLen = _get_range_bits_value(adtsHeader, AAC_ADTS_FRAME_LEN_OFFSET, 13);
-
- if(*frameLen == 0 || *frameLen > (pData->streamInfo.fileSize - filePosBefore)) {
- *frameLen = 0;
- ret = MMFILE_AAC_PARSER_FAIL;
- goto function_end;
- }
+
+ if (mmfile_tell(pData->hFile) >= pData->streamInfo.fileSize) {
+ *frameLen = 0;
+ ret = MMFILE_AAC_PARSER_FILE_END;
+ goto function_end;
+ }
+
+ if (!IS_AAC_ADTS_HEADER(adtsHeader)) {
+ *frameLen = 0;
+ ret = MMFILE_AAC_PARSER_FAIL;
+ goto function_end;
+ }
+
+ *frameLen = _get_range_bits_value(adtsHeader, AAC_ADTS_FRAME_LEN_OFFSET, 13);
+
+ if (*frameLen == 0 || *frameLen > (pData->streamInfo.fileSize - filePosBefore)) {
+ *frameLen = 0;
+ ret = MMFILE_AAC_PARSER_FAIL;
+ goto function_end;
+ }
function_end:
-
- mmfile_seek(pData->hFile, filePosBefore + *frameLen, MMFILE_SEEK_SET);
-
- return ret;
+
+ mmfile_seek(pData->hFile, filePosBefore + *frameLen, MMFILE_SEEK_SET);
+
+ return ret;
}
-int mmfile_aacparser_open (MMFileAACHandle *handle, const char *filenamec)
+int mmfile_aacparser_open(MMFileAACHandle *handle, const char *filenamec)
{
- tMMFILE_AAC_HANDLE *privateData = NULL;
- int ret = 0;
- unsigned char header[4] = {0,};
- int firstFrameLen = 0;
- int readed = 0;
-
- if (NULL == filenamec) {
- debug_error ("file source is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- privateData = mmfile_malloc (sizeof(tMMFILE_AAC_HANDLE));
- if (NULL == privateData) {
- debug_error ("file source is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- ret = mmfile_open (&privateData->hFile, filenamec, MMFILE_RDONLY);
- if(ret == MMFILE_UTIL_FAIL) {
- debug_error ("error: mmfile_open\n");
- goto exception;
- }
-
- /* Initialize the members of handle */
- _aac_init_handle(privateData);
-
- mmfile_seek (privateData->hFile, 0, MMFILE_SEEK_END);
- privateData->streamInfo.fileSize= mmfile_tell(privateData->hFile);
-
- mmfile_seek (privateData->hFile, 0, MMFILE_SEEK_SET);
-
- /* Search the existance of ID3 tag */
- ret = _search_id3tag(privateData);
- if(ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("Error in searching the ID3 tag\n");
- goto exception;
- }
-
- mmfile_seek (privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
- readed = mmfile_read (privateData->hFile, header, 4);
- if (readed != 4)
- goto exception;
-
- if(IS_AAC_ADIF_HEADER(header)) {
- privateData->formatType = AAC_FORMAT_ADIF;
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("AAC Format: ADIF\n");
-#endif
-
- }
- else if(IS_AAC_ADTS_HEADER(header)) {
- privateData->formatType = AAC_FORMAT_ADTS;
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("AAC Format: ADTS\n");
-#endif
-
- /* Verify whether the first frame size is proper */
- mmfile_seek (privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
- ret = _get_next_adts_frame_length(privateData, &firstFrameLen);
- if(ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("Invalid Frame length in ADTS header\n");
- goto exception;
- }
- }
- else {
- privateData->formatType = AAC_FORMAT_UNKNOWN;
- debug_error("AAC Format: UNKNOWN\n");
- goto exception;
- }
-
- *handle = privateData;
-
- return MMFILE_AAC_PARSER_SUCCESS;
+ tMMFILE_AAC_HANDLE *privateData = NULL;
+ int ret = 0;
+ unsigned char header[4] = {0, };
+ int firstFrameLen = 0;
+ int readed = 0;
+
+ if (NULL == filenamec) {
+ debug_error("file source is NULL\n");
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ privateData = mmfile_malloc(sizeof(tMMFILE_AAC_HANDLE));
+ if (NULL == privateData) {
+ debug_error("file source is NULL\n");
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ ret = mmfile_open(&privateData->hFile, filenamec, MMFILE_RDONLY);
+ if (ret == MMFILE_UTIL_FAIL) {
+ debug_error("error: mmfile_open\n");
+ goto exception;
+ }
+
+ /* Initialize the members of handle */
+ _aac_init_handle(privateData);
+
+ mmfile_seek(privateData->hFile, 0, MMFILE_SEEK_END);
+ privateData->streamInfo.fileSize = mmfile_tell(privateData->hFile);
+
+ mmfile_seek(privateData->hFile, 0, MMFILE_SEEK_SET);
+
+ /* Search the existance of ID3 tag */
+ ret = _search_id3tag(privateData);
+ if (ret == MMFILE_AAC_PARSER_FAIL) {
+ debug_error("Error in searching the ID3 tag\n");
+ goto exception;
+ }
+
+ mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
+ readed = mmfile_read(privateData->hFile, header, 4);
+ if (readed != 4)
+ goto exception;
+
+ if (IS_AAC_ADIF_HEADER(header)) {
+ privateData->formatType = AAC_FORMAT_ADIF;
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("AAC Format: ADIF\n");
+#endif
+
+ } else if (IS_AAC_ADTS_HEADER(header)) {
+ privateData->formatType = AAC_FORMAT_ADTS;
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("AAC Format: ADTS\n");
+#endif
+
+ /* Verify whether the first frame size is proper */
+ mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
+ ret = _get_next_adts_frame_length(privateData, &firstFrameLen);
+ if (ret == MMFILE_AAC_PARSER_FAIL) {
+ debug_error("Invalid Frame length in ADTS header\n");
+ goto exception;
+ }
+ } else {
+ privateData->formatType = AAC_FORMAT_UNKNOWN;
+ debug_error("AAC Format: UNKNOWN\n");
+ goto exception;
+ }
+
+ *handle = privateData;
+
+ return MMFILE_AAC_PARSER_SUCCESS;
exception:
- if (privateData) {
- mmfile_close (privateData->hFile);
- mmfile_free (privateData);
- *handle = NULL;
- }
- return MMFILE_AAC_PARSER_FAIL;
-
+ if (privateData) {
+ mmfile_close(privateData->hFile);
+ mmfile_free(privateData);
+ *handle = NULL;
+ }
+ return MMFILE_AAC_PARSER_FAIL;
+
}
-int mmfile_aacparser_get_stream_info (MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo)
+int mmfile_aacparser_get_stream_info(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo)
{
- tMMFILE_AAC_HANDLE *privateData = NULL;
- int frameLen = 0;
- long long totalFrames = 0, totalFrameLength = 0;
- unsigned long long streamDataSize = 0;
- int ret = MMFILE_AAC_PARSER_SUCCESS;
-
- if (NULL == handle || NULL == aacinfo) {
- debug_error ("handle is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- privateData = (tMMFILE_AAC_HANDLE *) handle;
-
- if(privateData->formatType == AAC_FORMAT_ADIF) {
- ret = _parse_aac_adif_header(privateData);
- aacinfo->iseekable = 0;
- }
- else {
- ret = _parse_aac_adts_header(privateData);
- aacinfo->iseekable = 1;
- }
-
- if(ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("Error in parsing the stream header\n");
- return ret;
- }
-
- mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
-
- if(privateData->formatType == AAC_FORMAT_ADTS) {
-
- while(TRUE) {
- ret = _get_next_adts_frame_length(privateData, &frameLen);
- if(ret != MMFILE_AAC_PARSER_SUCCESS) {
- break;
- }
- totalFrameLength += frameLen - MMFILE_AAC_ADTS_HEADER_MAX_SIZE;
- totalFrames++;
- }
-
- if(ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("Found corrupted frames!!! Ignoring\n");
- }
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("No of ADTS frames: %d\n", totalFrames);
-#endif
- privateData->streamInfo.frameRate = privateData->streamInfo.samplingRate / AAC_ADTS_SAMPLES_PER_FRAME;
-
- if(privateData->streamInfo.frameRate)
- privateData->streamInfo.duration = (totalFrames * 1000) / privateData->streamInfo.frameRate;
- else privateData->streamInfo.duration = 0;
-
- if(privateData->streamInfo.duration)
- privateData->streamInfo.bitRate = (totalFrameLength * 8 * 1000) / (privateData->streamInfo.duration);
- else privateData->streamInfo.bitRate = 0;
-
- }
- else {
- streamDataSize = (unsigned long long)privateData->streamInfo.fileSize - privateData->tagInfoSize;
- privateData->streamInfo.duration = streamDataSize * 8 * 1000 / privateData->streamInfo.bitRate;
- }
-
- // Return the stream info structure
- memcpy(aacinfo, &(privateData->streamInfo), sizeof(tMMFILE_AAC_STREAM_INFO));
-
- return MMFILE_AAC_PARSER_SUCCESS;
+ tMMFILE_AAC_HANDLE *privateData = NULL;
+ int frameLen = 0;
+ long long totalFrames = 0, totalFrameLength = 0;
+ unsigned long long streamDataSize = 0;
+ int ret = MMFILE_AAC_PARSER_SUCCESS;
+
+ if (NULL == handle || NULL == aacinfo) {
+ debug_error("handle is NULL\n");
+ return MMFILE_AAC_PARSER_FAIL;
+ }
+
+ privateData = (tMMFILE_AAC_HANDLE *) handle;
+
+ if (privateData->formatType == AAC_FORMAT_ADIF) {
+ ret = _parse_aac_adif_header(privateData);
+ aacinfo->iseekable = 0;
+ } else {
+ ret = _parse_aac_adts_header(privateData);
+ aacinfo->iseekable = 1;
+ }
+
+ if (ret == MMFILE_AAC_PARSER_FAIL) {
+ debug_error("Error in parsing the stream header\n");
+ return ret;
+ }
+
+ mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
+
+ if (privateData->formatType == AAC_FORMAT_ADTS) {
+
+ while (TRUE) {
+ ret = _get_next_adts_frame_length(privateData, &frameLen);
+ if (ret != MMFILE_AAC_PARSER_SUCCESS) {
+ break;
+ }
+ totalFrameLength += frameLen - MMFILE_AAC_ADTS_HEADER_MAX_SIZE;
+ totalFrames++;
+ }
+
+ if (ret == MMFILE_AAC_PARSER_FAIL) {
+ debug_error("Found corrupted frames!!! Ignoring\n");
+ }
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("No of ADTS frames: %d\n", totalFrames);
+#endif
+ privateData->streamInfo.frameRate = privateData->streamInfo.samplingRate / AAC_ADTS_SAMPLES_PER_FRAME;
+
+ if (privateData->streamInfo.frameRate)
+ privateData->streamInfo.duration = (totalFrames * 1000) / privateData->streamInfo.frameRate;
+ else privateData->streamInfo.duration = 0;
+
+ if (privateData->streamInfo.duration)
+ privateData->streamInfo.bitRate = (totalFrameLength * 8 * 1000) / (privateData->streamInfo.duration);
+ else privateData->streamInfo.bitRate = 0;
+
+ } else {
+ streamDataSize = (unsigned long long)privateData->streamInfo.fileSize - privateData->tagInfoSize;
+ privateData->streamInfo.duration = streamDataSize * 8 * 1000 / privateData->streamInfo.bitRate;
+ }
+
+ /* Return the stream info structure */
+ memcpy(aacinfo, &(privateData->streamInfo), sizeof(tMMFILE_AAC_STREAM_INFO));
+
+ return MMFILE_AAC_PARSER_SUCCESS;
}
-int mmfile_aacparser_get_tag_info (MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *tagInfo)
+int mmfile_aacparser_get_tag_info(MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *tagInfo)
{
tMMFILE_AAC_HANDLE *privateData = NULL;
int ret = 0;
if (NULL == handle || NULL == tagInfo) {
- debug_error ("handle is NULL\n");
+ debug_error("handle is NULL\n");
return MMFILE_AAC_PARSER_FAIL;
}
privateData = (tMMFILE_AAC_HANDLE *) handle;
- if(privateData->id3Handle.tagV2Info.tagVersion == 0)
- {
- debug_warning ("There is no Tag info\n");
+ if (privateData->id3Handle.tagV2Info.tagVersion == 0) {
+ debug_warning("There is no Tag info\n");
return MMFILE_AAC_PARSER_SUCCESS;
}
ret = _parse_id3_tag(privateData);
- if(ret == MMFILE_AAC_PARSER_FAIL) {
- debug_warning ("Error in parsing the Tag info\n");
+ if (ret == MMFILE_AAC_PARSER_FAIL) {
+ debug_warning("Error in parsing the Tag info\n");
return ret;
}
- // Return the tag info structure
+ /* Return the tag info structure */
memcpy(tagInfo, &(privateData->tagInfo), sizeof(tMMFILE_AAC_TAG_INFO));
return MMFILE_AAC_PARSER_SUCCESS;
}
-int mmfile_aacparser_close (MMFileAACHandle handle)
+int mmfile_aacparser_close(MMFileAACHandle handle)
{
- tMMFILE_AAC_HANDLE *privateData = NULL;
+ tMMFILE_AAC_HANDLE *privateData = NULL;
- if (NULL == handle) {
- debug_error ("handle is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
+ if (NULL == handle) {
+ debug_error("handle is NULL\n");
+ return MMFILE_AAC_PARSER_FAIL;
+ }
- privateData = (tMMFILE_AAC_HANDLE *) handle;
- mm_file_free_AvFileContentInfo(&privateData->id3Handle);
-
- mmfile_close(privateData->hFile);
+ privateData = (tMMFILE_AAC_HANDLE *) handle;
+ mm_file_free_AvFileContentInfo(&privateData->id3Handle);
+
+ mmfile_close(privateData->hFile);
- return MMFILE_AAC_PARSER_SUCCESS;
+ return MMFILE_AAC_PARSER_SUCCESS;
}
-
-
+
+
/* mm plugin interface */
-int mmfile_format_read_stream_aac (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_aac (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_aac (MMFileFormatContext *formatContext);
-int mmfile_format_close_aac (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_aac(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_aac(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_aac(MMFileFormatContext *formatContext);
+int mmfile_format_close_aac(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_aac (MMFileFormatContext *formatContext)
+int mmfile_format_open_aac(MMFileFormatContext *formatContext)
{
MMFileAACHandle handle = NULL;
int res = MMFILE_FORMAT_FAIL;
if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error ("error: mmfile_format_open_aac\n");
+ debug_error("error: mmfile_format_open_aac\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
- res = MMFileFormatIsValidAAC (NULL, formatContext->uriFileName);
+ res = MMFileFormatIsValidAAC(NULL, formatContext->uriFileName);
if (res == 0) {
debug_error("It is not AAC file\n");
return MMFILE_FORMAT_FAIL;
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 1;
- res = mmfile_aacparser_open (&handle, formatContext->uriFileName);
+ res = mmfile_aacparser_open(&handle, formatContext->uriFileName);
if (MMFILE_AAC_PARSER_FAIL == res) {
- debug_error ("mmfile_aacparser_open\n");
+ debug_error("mmfile_aacparser_open\n");
return MMFILE_FORMAT_FAIL;
}
}
EXPORT_API
-int mmfile_format_read_stream_aac (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_aac(MMFileFormatContext *formatContext)
{
- MMFileAACHandle handle = NULL;
- tMMFILE_AAC_STREAM_INFO aacinfo = {0,};
- MMFileFormatStream *audioStream = NULL;
-
- int ret = MMFILE_FORMAT_FAIL;
-
- if (NULL == formatContext ) {
- debug_error ("error: invalid params\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- handle = formatContext->privateFormatData;
-
- ret = mmfile_aacparser_get_stream_info (handle, &aacinfo);
- if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error ("error: mmfile_aacparser_get_stream_info\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- formatContext->isseekable = aacinfo.iseekable;
- formatContext->duration = aacinfo.duration;
- formatContext->videoStreamId = -1;
- formatContext->videoTotalTrackNum = 0;
- formatContext->audioTotalTrackNum = aacinfo.numTracks;
- formatContext->nbStreams = 1;
-
- audioStream = mmfile_malloc (sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error ("error: calloc_audiostream\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- audioStream->streamType = MMFILE_AUDIO_STREAM;
- audioStream->codecId = MM_AUDIO_CODEC_AAC;
- audioStream->bitRate = aacinfo.bitRate;
- audioStream->framePerSec = aacinfo.frameRate;
- audioStream->width = 0;
- audioStream->height = 0;
- audioStream->nbChannel = aacinfo.numAudioChannels;
- audioStream->samplePerSec = aacinfo.samplingRate;
- formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
-
+ MMFileAACHandle handle = NULL;
+ tMMFILE_AAC_STREAM_INFO aacinfo = {0, };
+ MMFileFormatStream *audioStream = NULL;
+
+ int ret = MMFILE_FORMAT_FAIL;
+
+ if (NULL == formatContext) {
+ debug_error("error: invalid params\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ handle = formatContext->privateFormatData;
+
+ ret = mmfile_aacparser_get_stream_info(handle, &aacinfo);
+ if (MMFILE_FORMAT_SUCCESS != ret) {
+ debug_error("error: mmfile_aacparser_get_stream_info\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ formatContext->isseekable = aacinfo.iseekable;
+ formatContext->duration = aacinfo.duration;
+ formatContext->videoStreamId = -1;
+ formatContext->videoTotalTrackNum = 0;
+ formatContext->audioTotalTrackNum = aacinfo.numTracks;
+ formatContext->nbStreams = 1;
+
+ audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
+ if (NULL == audioStream) {
+ debug_error("error: calloc_audiostream\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ audioStream->streamType = MMFILE_AUDIO_STREAM;
+ audioStream->codecId = MM_AUDIO_CODEC_AAC;
+ audioStream->bitRate = aacinfo.bitRate;
+ audioStream->framePerSec = aacinfo.frameRate;
+ audioStream->width = 0;
+ audioStream->height = 0;
+ audioStream->nbChannel = aacinfo.numAudioChannels;
+ audioStream->samplePerSec = aacinfo.samplingRate;
+ formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
+
#ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
+ mmfile_format_print_contents(formatContext);
#endif
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
exception:
- return ret;
+ return ret;
}
EXPORT_API
-int mmfile_format_read_tag_aac (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_aac(MMFileFormatContext *formatContext)
{
- MMFileAACHandle handle = NULL;
- tMMFILE_AAC_TAG_INFO aacinfo = {0,};
- int ret= MMFILE_FORMAT_FAIL;
-
- if (NULL == formatContext) {
- debug_error ("error: invalid params\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- handle = formatContext->privateFormatData;
-
- ret = mmfile_aacparser_get_tag_info (handle, &aacinfo);
- if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_warning ("error: mmfile_aacparser_get_tag_info\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- if(aacinfo.title)
- formatContext->title = mmfile_strdup(aacinfo.title);
- if(aacinfo.author)
- formatContext->author = mmfile_strdup(aacinfo.author);
- if(aacinfo.artist)
- formatContext->artist = mmfile_strdup(aacinfo.artist);
- if(aacinfo.album)
- formatContext->album = mmfile_strdup(aacinfo.album);
- if(aacinfo.album_artist)
- formatContext->album_artist = mmfile_strdup(aacinfo.album_artist);
- if(aacinfo.year)
- formatContext->year = mmfile_strdup(aacinfo.year);
- if(aacinfo.copyright)
- formatContext->copyright = mmfile_strdup(aacinfo.copyright);
- if(aacinfo.comment)
- formatContext->comment = mmfile_strdup(aacinfo.comment);
- if(aacinfo.genre)
- formatContext->genre = mmfile_strdup(aacinfo.genre);
- if(aacinfo.tracknum)
- formatContext->tagTrackNum= mmfile_strdup(aacinfo.tracknum);
- if(aacinfo.composer)
- formatContext->composer = mmfile_strdup(aacinfo.composer);
- if(aacinfo.classification)
- formatContext->classification = mmfile_strdup(aacinfo.classification);
- if(aacinfo.rating)
- formatContext->rating = mmfile_strdup(aacinfo.rating); /*not exist rating tag in id3*/
- if(aacinfo.conductor)
- formatContext->conductor = mmfile_strdup(aacinfo.conductor);
- if(aacinfo.artworkMime)
- formatContext->artworkMime = mmfile_strdup(aacinfo.artworkMime);
- if(aacinfo.artwork) {
- formatContext->artworkSize = aacinfo.artworkSize;
- formatContext->artwork = mmfile_malloc(aacinfo.artworkSize);
- if(formatContext->artwork == NULL) {
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
- memcpy(formatContext->artwork, aacinfo.artwork, aacinfo.artworkSize);
- }
+ MMFileAACHandle handle = NULL;
+ tMMFILE_AAC_TAG_INFO aacinfo = {0, };
+ int ret = MMFILE_FORMAT_FAIL;
+
+ if (NULL == formatContext) {
+ debug_error("error: invalid params\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ handle = formatContext->privateFormatData;
+
+ ret = mmfile_aacparser_get_tag_info(handle, &aacinfo);
+ if (MMFILE_FORMAT_SUCCESS != ret) {
+ debug_warning("error: mmfile_aacparser_get_tag_info\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ if (aacinfo.title)
+ formatContext->title = mmfile_strdup(aacinfo.title);
+ if (aacinfo.author)
+ formatContext->author = mmfile_strdup(aacinfo.author);
+ if (aacinfo.artist)
+ formatContext->artist = mmfile_strdup(aacinfo.artist);
+ if (aacinfo.album)
+ formatContext->album = mmfile_strdup(aacinfo.album);
+ if (aacinfo.album_artist)
+ formatContext->album_artist = mmfile_strdup(aacinfo.album_artist);
+ if (aacinfo.year)
+ formatContext->year = mmfile_strdup(aacinfo.year);
+ if (aacinfo.copyright)
+ formatContext->copyright = mmfile_strdup(aacinfo.copyright);
+ if (aacinfo.comment)
+ formatContext->comment = mmfile_strdup(aacinfo.comment);
+ if (aacinfo.genre)
+ formatContext->genre = mmfile_strdup(aacinfo.genre);
+ if (aacinfo.tracknum)
+ formatContext->tagTrackNum = mmfile_strdup(aacinfo.tracknum);
+ if (aacinfo.composer)
+ formatContext->composer = mmfile_strdup(aacinfo.composer);
+ if (aacinfo.classification)
+ formatContext->classification = mmfile_strdup(aacinfo.classification);
+ if (aacinfo.rating)
+ formatContext->rating = mmfile_strdup(aacinfo.rating); /*not exist rating tag in id3*/
+ if (aacinfo.conductor)
+ formatContext->conductor = mmfile_strdup(aacinfo.conductor);
+ if (aacinfo.artworkMime)
+ formatContext->artworkMime = mmfile_strdup(aacinfo.artworkMime);
+ if (aacinfo.artwork) {
+ formatContext->artworkSize = aacinfo.artworkSize;
+ formatContext->artwork = mmfile_malloc(aacinfo.artworkSize);
+ if (formatContext->artwork == NULL) {
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+ memcpy(formatContext->artwork, aacinfo.artwork, aacinfo.artworkSize);
+ }
#ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
+ mmfile_format_print_contents(formatContext);
#endif
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
exception:
- return ret;
+ return ret;
}
EXPORT_API
-int mmfile_format_read_frame_aac (MMFileFormatContext *formatContext,
- unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_aac(MMFileFormatContext *formatContext,
+ unsigned int timestamp, MMFileFormatFrame *frame)
{
- debug_error ("error: mmfile_format_read_frame_aac, no handling\n");
+ debug_error("error: mmfile_format_read_frame_aac, no handling\n");
- return MMFILE_FORMAT_FAIL;
+ return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_close_aac (MMFileFormatContext *formatContext)
+int mmfile_format_close_aac(MMFileFormatContext *formatContext)
{
- MMFileAACHandle handle = NULL;
- int ret = MMFILE_FORMAT_FAIL;
-
- if (NULL == formatContext ) {
- debug_error ("error: invalid params\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- handle = formatContext->privateFormatData;
-
- if(NULL != handle) {
- ret = mmfile_aacparser_close(handle);
- if(ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("error: mmfile_format_close_aac\n");
- }
- }
-
- if(formatContext->streams[MMFILE_AUDIO_STREAM]) {
- mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
- formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
- }
-
- formatContext->ReadStream = NULL;
- formatContext->ReadFrame = NULL;
- formatContext->ReadTag = NULL;
- formatContext->Close = NULL;
-
- return MMFILE_FORMAT_SUCCESS;
+ MMFileAACHandle handle = NULL;
+ int ret = MMFILE_FORMAT_FAIL;
+
+ if (NULL == formatContext) {
+ debug_error("error: invalid params\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ handle = formatContext->privateFormatData;
+
+ if (NULL != handle) {
+ ret = mmfile_aacparser_close(handle);
+ if (ret == MMFILE_AAC_PARSER_FAIL) {
+ debug_error("error: mmfile_format_close_aac\n");
+ }
+ }
+
+ if (formatContext->streams[MMFILE_AUDIO_STREAM]) {
+ mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
+ formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
+ }
+
+ formatContext->ReadStream = NULL;
+ formatContext->ReadFrame = NULL;
+ formatContext->ReadTag = NULL;
+ formatContext->Close = NULL;
+
+ return MMFILE_FORMAT_SUCCESS;
}
#include "mm_file_format_amr.h"
-// Media specific definations
+/* Media specific definations */
#define NUM_AMR_NB_MODES 8
#define NUM_AMR_WB_MODES 9
#define MMFILE_AMR_MAX_HEADER_SIZE MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE
#define MMFILE_AMR_MIN_HEADER_SIZE MMFILE_AMR_SINGLE_CH_HEADER_SIZE
-
+
#define MMFILE_AMR_FRAME_DUR 20
#define AMR_NB_SAMPLES_PER_SEC 8000
#define AMR_WB_SAMPLES_PER_SEC 16000
typedef enum _mmfile_amr_format_types {
- AMR_FORMAT_NB,
- AMR_FORMAT_WB,
- AMR_FORMAT_UNKNOWN
-}eAmrFormatType;
+ AMR_FORMAT_NB,
+ AMR_FORMAT_WB,
+ AMR_FORMAT_UNKNOWN
+} eAmrFormatType;
typedef enum _mmfile_amr_channel_type {
- AMR_CHANNEL_TYPE_SINGLE,
- AMR_CHANNEL_TYPE_MULTIPLE,
- AMR_CHANNEL_TYPE_UNKNOWN
-}eAmrChannelType;
+ AMR_CHANNEL_TYPE_SINGLE,
+ AMR_CHANNEL_TYPE_MULTIPLE,
+ AMR_CHANNEL_TYPE_UNKNOWN
+} eAmrChannelType;
typedef struct _mmfile_amr_handle {
- MMFileIOHandle* hFile;
- long long duration;
- long long fileSize;
- unsigned int streamOffset;
- unsigned int bitRate;
- unsigned int samplingRate;
- unsigned int frameRate;
- unsigned int numAudioChannels;
- long long numFrames;
- unsigned int numTracks;
- int amrMode;
- eAmrFormatType amrFormat;
- eAmrChannelType amrChannelType;
-}tMMFILE_AMR_HANDLE;
-
-
+ MMFileIOHandle *hFile;
+ long long duration;
+ long long fileSize;
+ unsigned int streamOffset;
+ unsigned int bitRate;
+ unsigned int samplingRate;
+ unsigned int frameRate;
+ unsigned int numAudioChannels;
+ long long numFrames;
+ unsigned int numTracks;
+ int amrMode;
+ eAmrFormatType amrFormat;
+ eAmrChannelType amrChannelType;
+} tMMFILE_AMR_HANDLE;
+
+
typedef struct _mmfile_amr_mode_config {
- unsigned int bitRate;
- unsigned int frameSize;
-}tAmrModeConfig;
+ unsigned int bitRate;
+ unsigned int frameSize;
+} tAmrModeConfig;
/*RTP format only supported*/
/*mode vs bitRate-frameSize lookup table; [0]->AMR-NB [1]->AMR-WB */
-const tAmrModeConfig AmrModeConfigTable[2][16] =
-{
+const tAmrModeConfig AmrModeConfigTable[2][16] = {
{
{4750, 13}, {5150, 14}, {5900, 16}, {6700, 18},
{7400, 20}, {7950, 21}, {10200,27}, {12200,32},
{0, 1}, {0, 1}, {0, 1}, {0, 1},
}
};
-
-/* internal APIs */
-void _amr_init_handle(tMMFILE_AMR_HANDLE* pData)
+/* internal APIs */
+
+void _amr_init_handle(tMMFILE_AMR_HANDLE *pData)
{
- pData->hFile = NULL;
- pData->duration = 0;
- pData->fileSize = 0L;
- pData->streamOffset = 0;
- pData->bitRate = 0;
- pData->samplingRate = 0;
- pData->frameRate = 0;
- pData->numAudioChannels = 1;
- pData->numTracks = 1;
- pData->numFrames = 0;
- pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
+ pData->hFile = NULL;
+ pData->duration = 0;
+ pData->fileSize = 0L;
+ pData->streamOffset = 0;
+ pData->bitRate = 0;
+ pData->samplingRate = 0;
+ pData->frameRate = 0;
+ pData->numAudioChannels = 1;
+ pData->numTracks = 1;
+ pData->numFrames = 0;
+ pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
}
-int _parse_amr_header(tMMFILE_AMR_HANDLE* pData)
+int _parse_amr_header(tMMFILE_AMR_HANDLE *pData)
{
-
- unsigned char header[MMFILE_AMR_MAX_HEADER_SIZE];
- int ret = MMFILE_AMR_PARSER_SUCCESS;
-
- ret = mmfile_read(pData->hFile, header, MMFILE_AMR_MAX_HEADER_SIZE);
- if(ret != MMFILE_AMR_MAX_HEADER_SIZE) {
- return MMFILE_AMR_PARSER_FAIL;
- }
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("\nAMR HEADER: [%2x] [%2x] [%2x] [%2x] [%2x]\n \
+
+ unsigned char header[MMFILE_AMR_MAX_HEADER_SIZE];
+ int ret = MMFILE_AMR_PARSER_SUCCESS;
+
+ ret = mmfile_read(pData->hFile, header, MMFILE_AMR_MAX_HEADER_SIZE);
+ if (ret != MMFILE_AMR_MAX_HEADER_SIZE) {
+ return MMFILE_AMR_PARSER_FAIL;
+ }
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("\nAMR HEADER: [%2x] [%2x] [%2x] [%2x] [%2x]\n \
[%2x] [%2x] [%2x] [%2x] [%2x]\n \
- [%2x] [%2x] [%2x] [%2x] [%2x]\n",
- header[0], header[1], header[2], header[3],header[4],
- header[5], header[6], header[7], header[8],header[9],
- header[10],header[11],header[12],header[13],header[14]);
+ [%2x] [%2x] [%2x] [%2x] [%2x]\n",
+ header[0], header[1], header[2], header[3], header[4],
+ header[5], header[6], header[7], header[8], header[9],
+ header[10], header[11], header[12], header[13], header[14]);
#endif
- if(!(memcmp(header, MMFILE_AMR_SINGLE_CH_HEADER, MMFILE_AMR_SINGLE_CH_HEADER_SIZE))) {
- pData->amrFormat = AMR_FORMAT_NB;
- pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
- pData->streamOffset = MMFILE_AMR_SINGLE_CH_HEADER_SIZE;
- }
-
- else if(!(memcmp(header, MMFILE_AMR_WB_SINGLE_CH_HEADER, MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE))) {
- pData->amrFormat = AMR_FORMAT_WB;
- pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
- pData->streamOffset = MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE;
- }
-
- else if(!(memcmp(header, MMFILE_AMR_MULTI_CH_HEADER, MMFILE_AMR_MULTI_CH_HEADER_SIZE))){
- pData->amrFormat = AMR_FORMAT_NB;
- pData->amrChannelType = AMR_CHANNEL_TYPE_MULTIPLE;
- pData->streamOffset = MMFILE_AMR_MULTI_CH_HEADER_SIZE;
- }
-
- else if(!(memcmp(header, MMFILE_AMR_WB_MULTI_CH_HEADER, MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE))) {
- pData->amrFormat = AMR_FORMAT_WB;
- pData->amrChannelType = AMR_CHANNEL_TYPE_MULTIPLE;
- pData->streamOffset = MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE;
- }
-
- else {
- pData->amrFormat = AMR_FORMAT_UNKNOWN;
- pData->amrChannelType = AMR_CHANNEL_TYPE_UNKNOWN;
- ret = MMFILE_AMR_PARSER_FAIL;
- }
-
- return ret;
+ if (!(memcmp(header, MMFILE_AMR_SINGLE_CH_HEADER, MMFILE_AMR_SINGLE_CH_HEADER_SIZE))) {
+ pData->amrFormat = AMR_FORMAT_NB;
+ pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
+ pData->streamOffset = MMFILE_AMR_SINGLE_CH_HEADER_SIZE;
+ }
+
+ else if (!(memcmp(header, MMFILE_AMR_WB_SINGLE_CH_HEADER, MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE))) {
+ pData->amrFormat = AMR_FORMAT_WB;
+ pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
+ pData->streamOffset = MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE;
+ }
+
+ else if (!(memcmp(header, MMFILE_AMR_MULTI_CH_HEADER, MMFILE_AMR_MULTI_CH_HEADER_SIZE))) {
+ pData->amrFormat = AMR_FORMAT_NB;
+ pData->amrChannelType = AMR_CHANNEL_TYPE_MULTIPLE;
+ pData->streamOffset = MMFILE_AMR_MULTI_CH_HEADER_SIZE;
+ }
+
+ else if (!(memcmp(header, MMFILE_AMR_WB_MULTI_CH_HEADER, MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE))) {
+ pData->amrFormat = AMR_FORMAT_WB;
+ pData->amrChannelType = AMR_CHANNEL_TYPE_MULTIPLE;
+ pData->streamOffset = MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE;
+ }
+
+ else {
+ pData->amrFormat = AMR_FORMAT_UNKNOWN;
+ pData->amrChannelType = AMR_CHANNEL_TYPE_UNKNOWN;
+ ret = MMFILE_AMR_PARSER_FAIL;
+ }
+
+ return ret;
}
-int _parse_amr_stream(tMMFILE_AMR_HANDLE* pData)
+int _parse_amr_stream(tMMFILE_AMR_HANDLE *pData)
{
int frameLen = 0;
unsigned char amrMode = 0;
int pos;
long long sum_bitrate = 0;
long long frames_bitrate = 0;
-
- buf = mmfile_malloc (AMR_MAX_READ_BUF_SZ);
+
+ buf = mmfile_malloc(AMR_MAX_READ_BUF_SZ);
if (!buf) {
- debug_error ("failed to memory allocaion.\n");
+ debug_error("failed to memory allocaion.\n");
return MMFILE_AMR_PARSER_FAIL;
}
for (readed = 0;;) {
- readed = mmfile_read (pData->hFile, buf, AMR_MAX_READ_BUF_SZ);
+ readed = mmfile_read(pData->hFile, buf, AMR_MAX_READ_BUF_SZ);
if (readed <= 0) break;
for (p = buf, pos = 0;;) {
- amrMode = AMR_GET_MODE ((*(char *)p));
+ amrMode = AMR_GET_MODE((*(char *)p));
frameLen = AmrModeConfigTable[pData->amrFormat][amrMode].frameSize;
sum_bitrate += AmrModeConfigTable[pData->amrFormat][amrMode].bitRate;
pData->numFrames++;
if (pos == readed) {
break;
} else if (pos > readed) {
- mmfile_seek (pData->hFile, (pos - readed), MMFILE_SEEK_CUR);
+ mmfile_seek(pData->hFile, (pos - readed), MMFILE_SEEK_CUR);
break;
}
}
}
- mmfile_free (buf);
+ mmfile_free(buf);
- pData->duration = pData->numFrames * MMFILE_AMR_FRAME_DUR;
+ pData->duration = pData->numFrames * MMFILE_AMR_FRAME_DUR;
pData->frameRate = 1000 / MMFILE_AMR_FRAME_DUR;
- if(frames_bitrate) {
+ if (frames_bitrate) {
pData->bitRate = sum_bitrate / frames_bitrate;
}
}
-int mmfile_amrparser_open (MMFileAMRHandle *handle, const char *filenamec)
+int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *filenamec)
{
- tMMFILE_AMR_HANDLE *privateData = NULL;
- int ret = 0;
-
- if (NULL == filenamec || NULL == handle) {
- debug_error ("file source is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
-
- privateData = mmfile_malloc (sizeof(tMMFILE_AMR_HANDLE));
- if (NULL == privateData) {
- debug_error ("file source is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
-
- /* Initialize the members of handle */
- _amr_init_handle(privateData);
-
- ret = mmfile_open (&privateData->hFile, filenamec, MMFILE_RDONLY);
- if(ret == MMFILE_UTIL_FAIL) {
- debug_error ("error: mmfile_open\n");
- goto exception;
- }
-
- mmfile_seek (privateData->hFile, 0, MMFILE_SEEK_END);
- privateData->fileSize= mmfile_tell(privateData->hFile);
- mmfile_seek (privateData->hFile, 0, MMFILE_SEEK_SET);
-
- if(privateData->fileSize < MMFILE_AMR_MIN_HEADER_SIZE) {
- debug_error("Too small file to parse!!\n");
- goto exception;
- }
-
- ret = _parse_amr_header(privateData);
- if(ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error("Invalid AMR header\n");
- goto exception;
- }
-
- if(privateData->amrChannelType != AMR_CHANNEL_TYPE_SINGLE) {
- debug_error("Unsupported channel mode\n"); /*Need to study AMR_Format.txt, Pg:36*/
- goto exception;
- }
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("AMR Format Type: %s\n", \
- privateData->amrFormat == AMR_FORMAT_NB? "AMR-NB":"AMR-WB");
+ tMMFILE_AMR_HANDLE *privateData = NULL;
+ int ret = 0;
+
+ if (NULL == filenamec || NULL == handle) {
+ debug_error("file source is NULL\n");
+ return MMFILE_AMR_PARSER_FAIL;
+ }
+
+ privateData = mmfile_malloc(sizeof(tMMFILE_AMR_HANDLE));
+ if (NULL == privateData) {
+ debug_error("file source is NULL\n");
+ return MMFILE_AMR_PARSER_FAIL;
+ }
+
+ /* Initialize the members of handle */
+ _amr_init_handle(privateData);
+
+ ret = mmfile_open(&privateData->hFile, filenamec, MMFILE_RDONLY);
+ if (ret == MMFILE_UTIL_FAIL) {
+ debug_error("error: mmfile_open\n");
+ goto exception;
+ }
+
+ mmfile_seek(privateData->hFile, 0, MMFILE_SEEK_END);
+ privateData->fileSize = mmfile_tell(privateData->hFile);
+ mmfile_seek(privateData->hFile, 0, MMFILE_SEEK_SET);
+
+ if (privateData->fileSize < MMFILE_AMR_MIN_HEADER_SIZE) {
+ debug_error("Too small file to parse!!\n");
+ goto exception;
+ }
+
+ ret = _parse_amr_header(privateData);
+ if (ret == MMFILE_AMR_PARSER_FAIL) {
+ debug_error("Invalid AMR header\n");
+ goto exception;
+ }
+
+ if (privateData->amrChannelType != AMR_CHANNEL_TYPE_SINGLE) {
+ debug_error("Unsupported channel mode\n"); /*Need to study AMR_Format.txt, Pg:36*/
+ goto exception;
+ }
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("AMR Format Type: %s\n", \
+ privateData->amrFormat == AMR_FORMAT_NB ? "AMR-NB" : "AMR-WB");
#endif
- *handle = privateData;
+ *handle = privateData;
+
+ return MMFILE_AMR_PARSER_SUCCESS;
- return MMFILE_AMR_PARSER_SUCCESS;
-
exception:
- if (privateData) {
- mmfile_close (privateData->hFile);
- mmfile_free (privateData);
- *handle = NULL;
- }
- return MMFILE_AMR_PARSER_FAIL;
-
+ if (privateData) {
+ mmfile_close(privateData->hFile);
+ mmfile_free(privateData);
+ *handle = NULL;
+ }
+ return MMFILE_AMR_PARSER_FAIL;
+
}
-int mmfile_amrparser_get_stream_info (MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo)
+int mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo)
{
- tMMFILE_AMR_HANDLE *privateData = NULL;
- int ret;
-
- if (NULL == handle || NULL == amrinfo) {
- debug_error ("handle is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
-
- privateData = (tMMFILE_AMR_HANDLE *) handle;
-
- mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
-
- ret = _parse_amr_stream(privateData);
- if(ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error("Error in parsing the stream\n");
- return ret;
- }
-
- amrinfo->duration = privateData->duration;
- amrinfo->fileSize = privateData->fileSize;
- amrinfo->bitRate = privateData->bitRate;
- amrinfo->frameRate = privateData->frameRate;
- amrinfo->numAudioChannels = 1;
- amrinfo->numTracks = 1;
-
- if(privateData->amrFormat == AMR_FORMAT_NB) {
- amrinfo->samplingRate = AMR_NB_SAMPLES_PER_SEC;
- }
- else {
- amrinfo->samplingRate = AMR_WB_SAMPLES_PER_SEC;
- }
-
- return MMFILE_AMR_PARSER_SUCCESS;
+ tMMFILE_AMR_HANDLE *privateData = NULL;
+ int ret;
+
+ if (NULL == handle || NULL == amrinfo) {
+ debug_error("handle is NULL\n");
+ return MMFILE_AMR_PARSER_FAIL;
+ }
+
+ privateData = (tMMFILE_AMR_HANDLE *) handle;
+
+ mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
+
+ ret = _parse_amr_stream(privateData);
+ if (ret == MMFILE_AMR_PARSER_FAIL) {
+ debug_error("Error in parsing the stream\n");
+ return ret;
+ }
+
+ amrinfo->duration = privateData->duration;
+ amrinfo->fileSize = privateData->fileSize;
+ amrinfo->bitRate = privateData->bitRate;
+ amrinfo->frameRate = privateData->frameRate;
+ amrinfo->numAudioChannels = 1;
+ amrinfo->numTracks = 1;
+
+ if (privateData->amrFormat == AMR_FORMAT_NB) {
+ amrinfo->samplingRate = AMR_NB_SAMPLES_PER_SEC;
+ } else {
+ amrinfo->samplingRate = AMR_WB_SAMPLES_PER_SEC;
+ }
+
+ return MMFILE_AMR_PARSER_SUCCESS;
}
-int mmfile_amrparser_close (MMFileAMRHandle handle)
+int mmfile_amrparser_close(MMFileAMRHandle handle)
{
- tMMFILE_AMR_HANDLE *privateData = NULL;
+ tMMFILE_AMR_HANDLE *privateData = NULL;
+
+ if (NULL == handle) {
+ debug_error("handle is NULL\n");
+ return MMFILE_AMR_PARSER_FAIL;
+ }
- if (NULL == handle) {
- debug_error ("handle is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
+ privateData = (tMMFILE_AMR_HANDLE *) handle;
- privateData = (tMMFILE_AMR_HANDLE *) handle;
-
- mmfile_close(privateData->hFile);
+ mmfile_close(privateData->hFile);
- return MMFILE_AMR_PARSER_SUCCESS;
+ return MMFILE_AMR_PARSER_SUCCESS;
}
-
-
-
+
+
+
/* mm plugin interface */
-int mmfile_format_read_stream_amr (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_amr (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_amr (MMFileFormatContext *formatContext);
-int mmfile_format_close_amr (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_amr(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_amr(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_amr(MMFileFormatContext *formatContext);
+int mmfile_format_close_amr(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_amr (MMFileFormatContext *formatContext)
+int mmfile_format_open_amr(MMFileFormatContext *formatContext)
{
MMFileAMRHandle handle = NULL;
int res = MMFILE_FORMAT_FAIL;
if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error ("error: mmfile_format_open_amr\n");
+ debug_error("error: mmfile_format_open_amr\n");
return MMFILE_FORMAT_FAIL;
}
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 1;
- res = mmfile_amrparser_open (&handle, formatContext->uriFileName);
+ res = mmfile_amrparser_open(&handle, formatContext->uriFileName);
if (MMFILE_AMR_PARSER_FAIL == res) {
- debug_error ("mmfile_amrparser_open\n");
+ debug_error("mmfile_amrparser_open\n");
return MMFILE_FORMAT_FAIL;
}
}
EXPORT_API
-int mmfile_format_read_stream_amr (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_amr(MMFileFormatContext *formatContext)
{
- MMFileAMRHandle handle = NULL;
- tMMFILE_AMR_STREAM_INFO amrinfo = {0,};
- MMFileFormatStream *audioStream = NULL;
-
- int ret = MMFILE_FORMAT_FAIL;
-
- if (NULL == formatContext ) {
- debug_error ("error: invalid params\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- handle = formatContext->privateFormatData;
-
- ret = mmfile_amrparser_get_stream_info (handle, &amrinfo);
- if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error ("error: mmfile_amrparser_get_stream_info\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- formatContext->duration = amrinfo.duration;
- formatContext->videoStreamId = -1;
- formatContext->videoTotalTrackNum = 0;
- formatContext->audioTotalTrackNum = amrinfo.numTracks;
- formatContext->nbStreams = 1;
-
- audioStream = mmfile_malloc (sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error ("error: calloc_audiostream\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- audioStream->streamType = MMFILE_AUDIO_STREAM;
- audioStream->codecId = MM_AUDIO_CODEC_AMR;
- audioStream->bitRate = amrinfo.bitRate;
- audioStream->framePerSec = amrinfo.frameRate;
- audioStream->width = 0;
- audioStream->height = 0;
- audioStream->nbChannel = amrinfo.numAudioChannels;
- audioStream->samplePerSec = amrinfo.samplingRate;
- formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
-
+ MMFileAMRHandle handle = NULL;
+ tMMFILE_AMR_STREAM_INFO amrinfo = {0, };
+ MMFileFormatStream *audioStream = NULL;
+
+ int ret = MMFILE_FORMAT_FAIL;
+
+ if (NULL == formatContext) {
+ debug_error("error: invalid params\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ handle = formatContext->privateFormatData;
+
+ ret = mmfile_amrparser_get_stream_info(handle, &amrinfo);
+ if (MMFILE_FORMAT_SUCCESS != ret) {
+ debug_error("error: mmfile_amrparser_get_stream_info\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ formatContext->duration = amrinfo.duration;
+ formatContext->videoStreamId = -1;
+ formatContext->videoTotalTrackNum = 0;
+ formatContext->audioTotalTrackNum = amrinfo.numTracks;
+ formatContext->nbStreams = 1;
+
+ audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
+ if (NULL == audioStream) {
+ debug_error("error: calloc_audiostream\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ audioStream->streamType = MMFILE_AUDIO_STREAM;
+ audioStream->codecId = MM_AUDIO_CODEC_AMR;
+ audioStream->bitRate = amrinfo.bitRate;
+ audioStream->framePerSec = amrinfo.frameRate;
+ audioStream->width = 0;
+ audioStream->height = 0;
+ audioStream->nbChannel = amrinfo.numAudioChannels;
+ audioStream->samplePerSec = amrinfo.samplingRate;
+ formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
+
#ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
+ mmfile_format_print_contents(formatContext);
#endif
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
exception:
- return ret;
+ return ret;
}
EXPORT_API
-int mmfile_format_read_tag_amr (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_amr(MMFileFormatContext *formatContext)
{
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_frame_amr (MMFileFormatContext *formatContext,
- unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_amr(MMFileFormatContext *formatContext,
+ unsigned int timestamp, MMFileFormatFrame *frame)
{
- debug_error ("error: mmfile_format_read_frame_amr, no handling\n");
-
- return MMFILE_FORMAT_FAIL;
+ debug_error("error: mmfile_format_read_frame_amr, no handling\n");
+
+ return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_close_amr (MMFileFormatContext *formatContext)
+int mmfile_format_close_amr(MMFileFormatContext *formatContext)
{
- MMFileAMRHandle handle = NULL;
- int ret = MMFILE_FORMAT_FAIL;
-
- if (NULL == formatContext ) {
- debug_error ("error: invalid params\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- handle = formatContext->privateFormatData;
-
- if(NULL != handle) {
- ret = mmfile_amrparser_close(handle);
- if(ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error("error: mmfile_format_close_amr\n");
- }
- }
-
- if(formatContext->streams[MMFILE_AUDIO_STREAM]) {
- mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
- formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
- }
-
- formatContext->ReadStream = NULL;
- formatContext->ReadFrame = NULL;
- formatContext->ReadTag = NULL;
- formatContext->Close = NULL;
-
- return MMFILE_FORMAT_SUCCESS;
+ MMFileAMRHandle handle = NULL;
+ int ret = MMFILE_FORMAT_FAIL;
+
+ if (NULL == formatContext) {
+ debug_error("error: invalid params\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ handle = formatContext->privateFormatData;
+
+ if (NULL != handle) {
+ ret = mmfile_amrparser_close(handle);
+ if (ret == MMFILE_AMR_PARSER_FAIL) {
+ debug_error("error: mmfile_format_close_amr\n");
+ }
+ }
+
+ if (formatContext->streams[MMFILE_AUDIO_STREAM]) {
+ mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
+ formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
+ }
+
+ formatContext->ReadStream = NULL;
+ formatContext->ReadFrame = NULL;
+ formatContext->ReadTag = NULL;
+ formatContext->Close = NULL;
+
+ return MMFILE_FORMAT_SUCCESS;
}
/* plugin manadatory API */
-int mmfile_format_read_stream_dummy (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_dummy (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_dummy (MMFileFormatContext *formatContext);
-int mmfile_format_close_dummy (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_dummy(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_dummy(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_dummy(MMFileFormatContext *formatContext);
+int mmfile_format_close_dummy(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_dummy (MMFileFormatContext *formatContext)
+int mmfile_format_open_dummy(MMFileFormatContext *formatContext)
{
- debug_warning ("called mmfile_format_open_dummy\n");
-
- formatContext->ReadStream = mmfile_format_read_stream_dummy;
- formatContext->ReadFrame = mmfile_format_read_frame_dummy;
- formatContext->ReadTag = mmfile_format_read_tag_dummy;
- formatContext->Close = mmfile_format_close_dummy;
-
- return MMFILE_FORMAT_SUCCESS;
+ debug_warning("called mmfile_format_open_dummy\n");
+
+ formatContext->ReadStream = mmfile_format_read_stream_dummy;
+ formatContext->ReadFrame = mmfile_format_read_frame_dummy;
+ formatContext->ReadTag = mmfile_format_read_tag_dummy;
+ formatContext->Close = mmfile_format_close_dummy;
+
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_stream_dummy (MMFileFormatContext * formatContext)
+int mmfile_format_read_stream_dummy(MMFileFormatContext *formatContext)
{
- debug_warning ("called mmfile_format_read_stream_dummy\n");
- return MMFILE_FORMAT_SUCCESS;
+ debug_warning("called mmfile_format_read_stream_dummy\n");
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_frame_dummy (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_dummy(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
- debug_warning ("called mmfile_format_read_frame_dummy\n");
- return MMFILE_FORMAT_SUCCESS;
+ debug_warning("called mmfile_format_read_frame_dummy\n");
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_tag_dummy (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_dummy(MMFileFormatContext *formatContext)
{
- debug_warning ("called mmfile_format_read_tag_dummy\n");
- return MMFILE_FORMAT_SUCCESS;
+ debug_warning("called mmfile_format_read_tag_dummy\n");
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_close_dummy (MMFileFormatContext *formatContext)
+int mmfile_format_close_dummy(MMFileFormatContext *formatContext)
{
- debug_warning ("called mmfile_format_close_dummy\n");
- if (formatContext)
- {
- formatContext->ReadStream = NULL;
- formatContext->ReadFrame = NULL;
- formatContext->ReadTag = NULL;
- formatContext->Close = NULL;
- }
-
- return MMFILE_FORMAT_SUCCESS;
+ debug_warning("called mmfile_format_close_dummy\n");
+ if (formatContext) {
+ formatContext->ReadStream = NULL;
+ formatContext->ReadFrame = NULL;
+ formatContext->ReadTag = NULL;
+ formatContext->Close = NULL;
+ }
+
+ return MMFILE_FORMAT_SUCCESS;
}
#include <stdlib.h>
#include <libavformat/avformat.h>
+#include <libavformat/url.h>
#include <libavcodec/avcodec.h>
#include <libavutil/samplefmt.h>
#ifdef __MMFILE_FFMPEG_V085__
#define _SHORT_MEDIA_LIMIT 2000 /* under X seconds duration*/
-extern int img_convert (AVPicture *dst, int dst_pix_fmt, const AVPicture *src, int src_pix_fmt,int src_width, int src_height);
+extern int img_convert(AVPicture *dst, int dst_pix_fmt, const AVPicture *src, int src_pix_fmt, int src_width, int src_height);
/* internal functions */
-static int _is_good_pgm (unsigned char *buf, int wrap, int xsize, int ysize);
+static int _is_good_pgm(unsigned char *buf, int wrap, int xsize, int ysize);
#ifdef MMFILE_FORMAT_DEBUG_DUMP
-static void _save_pgm (unsigned char *buf, int wrap, int xsize, int ysize, char *filename);
+static void _save_pgm(unsigned char *buf, int wrap, int xsize, int ysize, char *filename);
#endif
#ifdef __MMFILE_TEST_MODE__
-static void _dump_av_packet (AVPacket *pkt);
+static void _dump_av_packet(AVPacket *pkt);
#endif
-static int _get_video_fps (int frame_cnt, int duration, AVRational r_frame_rate, int is_roundup);
-static int _get_first_good_video_frame (AVFormatContext *pFormatCtx, AVCodecContext *pCodecCtx, int videoStream, AVFrame **pFrame, int cdis);
+static int _get_video_fps(int frame_cnt, int duration, AVRational r_frame_rate, int is_roundup);
+static int _get_first_good_video_frame(AVFormatContext *pFormatCtx, AVCodecContext *pCodecCtx, int videoStream, AVFrame **pFrame, int cdis);
-static int ConvertVideoCodecEnum (int AVVideoCodecID);
-static int ConvertAudioCodecEnum (int AVAudioCodecID);
+static int ConvertVideoCodecEnum(int AVVideoCodecID);
+static int ConvertAudioCodecEnum(int AVAudioCodecID);
/* plugin manadatory API */
-int mmfile_format_read_stream_ffmpg (MMFileFormatContext * formatContext);
-int mmfile_format_read_frame_ffmpg (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_ffmpg (MMFileFormatContext *formatContext);
-int mmfile_format_close_ffmpg (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_ffmpg(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_ffmpg(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_ffmpg(MMFileFormatContext *formatContext);
+int mmfile_format_close_ffmpg(MMFileFormatContext *formatContext);
static int getMimeType(int formatId, char *mimeType, int buf_size);
EXPORT_API
-int mmfile_format_open_ffmpg (MMFileFormatContext *formatContext)
+int mmfile_format_open_ffmpg(MMFileFormatContext *formatContext)
{
AVFormatContext *pFormatCtx = NULL;
AVInputFormat *grab_iformat = NULL;
int ret = 0;
- int i;
+ unsigned int i;
#ifdef DRM_SUPPORT
- drm_content_info_s contentInfo = {0,};
+ drm_content_info_s contentInfo = {0, };
#endif
- char ffmpegFormatName[MMFILE_FILE_FMT_MAX_LEN] = {0,};
- char mimeType[MMFILE_MIMETYPE_MAX_LEN] = {0,};
+ char ffmpegFormatName[MMFILE_FILE_FMT_MAX_LEN] = {0, };
+ char mimeType[MMFILE_MIMETYPE_MAX_LEN] = {0, };
formatContext->ReadStream = mmfile_format_read_stream_ffmpg;
formatContext->ReadFrame = mmfile_format_read_frame_ffmpg;
formatContext->Close = mmfile_format_close_ffmpg;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ffmpeg version: %d\n", avformat_version ());
+ debug_msg("ffmpeg version: %d\n", avformat_version());
/**
* FFMPEG DEBUG LEVEL
* AV_LOG_QUIET -1
* AV_LOG_INFO 1
* AV_LOG_VERBOSE 1
* AV_LOG_DEBUG 2
- */
- av_log_set_level (AV_LOG_DEBUG);
+ */
+ av_log_set_level(AV_LOG_DEBUG);
#else
- av_log_set_level (AV_LOG_QUIET);
+ av_log_set_level(AV_LOG_QUIET);
#endif
av_register_all();
if (formatContext->filesrc->type == MM_FILE_SRC_TYPE_MEMORY) {
-#if (defined __MMFILE_FFMPEG_V085__ && ! defined __MMFILE_LIBAV_VERSION__)
- ffurl_register_protocol(&MMFileMEMProtocol, sizeof (URLProtocol));
+#if (defined __MMFILE_FFMPEG_V085__ && !defined __MMFILE_LIBAV_VERSION__)
+ ffurl_register_protocol(&MMFileMEMProtocol, sizeof(URLProtocol));
#else
- register_protocol (&MMFileMEMProtocol);
+ ffurl_register_protocol(&MMFileMEMProtocol);
#endif
- if(getMimeType(formatContext->filesrc->memory.format,mimeType, MMFILE_MIMETYPE_MAX_LEN)< 0) {
- debug_error ("error: Error in MIME Type finding\n");
+ if (getMimeType(formatContext->filesrc->memory.format, mimeType, MMFILE_MIMETYPE_MAX_LEN) < 0) {
+ debug_error("error: Error in MIME Type finding\n");
return MMFILE_FORMAT_FAIL;
}
- memset (ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
+ memset(ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
- ret = mmfile_util_get_ffmpeg_format (mimeType,ffmpegFormatName);
+ ret = mmfile_util_get_ffmpeg_format(mimeType, ffmpegFormatName);
if (MMFILE_UTIL_SUCCESS != ret) {
- debug_error ("error: mmfile_util_get_ffmpeg_format\n");
+ debug_error("error: mmfile_util_get_ffmpeg_format\n");
return MMFILE_FORMAT_FAIL;
}
- grab_iformat = av_find_input_format (ffmpegFormatName);
+ grab_iformat = av_find_input_format(ffmpegFormatName);
if (NULL == grab_iformat) {
- debug_error ("error: cannot find format\n");
+ debug_error("error: cannot find format\n");
goto exception;
}
#ifdef __MMFILE_FFMPEG_V085__
- ret = avformat_open_input (&pFormatCtx, formatContext->uriFileName, grab_iformat, NULL);
+ ret = avformat_open_input(&pFormatCtx, formatContext->uriFileName, grab_iformat, NULL);
#else
- ret = av_open_input_file (&pFormatCtx, formatContext->uriFileName, grab_iformat, 0, NULL);
+ ret = av_open_input_file(&pFormatCtx, formatContext->uriFileName, grab_iformat, 0, NULL);
#endif
if (ret < 0) {
debug_error("error: cannot open %s %d\n", formatContext->uriFileName, ret);
}
#ifdef __MMFILE_FFMPEG_V085__
- ffurl_register_protocol(&MMFileDRMProtocol, sizeof (URLProtocol));
+ ffurl_register_protocol(&MMFileDRMProtocol, sizeof(URLProtocol));
#else
- register_protocol (&MMFileDRMProtocol);
+ ffurl_register_protocol(&MMFileDRMProtocol);
#endif
memset(&contentInfo, 0x0, sizeof(drm_content_info_s));
- if (DRM_RETURN_SUCCESS != drm_get_content_info (formatContext->filesrc->file.path, &contentInfo)) {
- debug_error ("error: drm_get_content_info\n");
+ if (DRM_RETURN_SUCCESS != drm_get_content_info(formatContext->filesrc->file.path, &contentInfo)) {
+ debug_error("error: drm_get_content_info\n");
return MMFILE_FORMAT_FAIL;
}
- memset (ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
+ memset(ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
- ret = mmfile_util_get_ffmpeg_format (contentInfo.mime_type, ffmpegFormatName);
+ ret = mmfile_util_get_ffmpeg_format(contentInfo.mime_type, ffmpegFormatName);
if (MMFILE_UTIL_SUCCESS != ret) {
- debug_error ("error: mmfile_util_get_ffmpeg_format\n");
+ debug_error("error: mmfile_util_get_ffmpeg_format\n");
return MMFILE_FORMAT_FAIL;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_warning ("FFMPEG: test........... : %s\n", ffmpegFormatName);
- debug_warning ("FFMPEG: DRM URI = %s\n", formatContext->uriFileName);
- debug_warning ("FFMPEG: ffmpeg name = %s\n", ffmpegFormatName);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_warning("FFMPEG: test........... : %s\n", ffmpegFormatName);
+ debug_warning("FFMPEG: DRM URI = %s\n", formatContext->uriFileName);
+ debug_warning("FFMPEG: ffmpeg name = %s\n", ffmpegFormatName);
+#endif
- grab_iformat = av_find_input_format (ffmpegFormatName);
+ grab_iformat = av_find_input_format(ffmpegFormatName);
if (NULL == grab_iformat) {
- debug_error ("error: cannot find format\n");
+ debug_error("error: cannot find format\n");
goto exception;
}
#ifdef __MMFILE_FFMPEG_V085__
- ret = avformat_open_input (&pFormatCtx, formatContext->uriFileName, grab_iformat, NULL);
+ ret = avformat_open_input(&pFormatCtx, formatContext->uriFileName, grab_iformat, NULL);
#else
- ret = av_open_input_file (&pFormatCtx, formatContext->uriFileName, grab_iformat, 0, NULL);
+ ret = av_open_input_file(&pFormatCtx, formatContext->uriFileName, grab_iformat, 0, NULL);
#endif
if (ret < 0) {
debug_error("error: cannot open %s %d\n", formatContext->uriFileName, ret);
formatContext->privateFormatData = pFormatCtx;
#endif
} else {
+#ifdef DRM_SUPPORT
HANDLING_DRM_DIVX:
+#endif
+
#ifdef __MMFILE_FFMPEG_V085__
ret = avformat_open_input(&pFormatCtx, formatContext->filesrc->file.path, NULL, NULL);
#else
}
if (!pFormatCtx/* || !(pFormatCtx->nb_streams > 0)*/) {
- debug_warning ("failed to find av stream. maybe corrupted data.\n");
+ debug_warning("failed to find av stream. maybe corrupted data.\n");
goto exception;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("number of stream: %d\n", pFormatCtx->nb_streams);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("number of stream: %d\n", pFormatCtx->nb_streams);
+#endif
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 0;
- for(i = 0; i < pFormatCtx->nb_streams; i++) {
+ for (i = 0; i < pFormatCtx->nb_streams; i++) {
#ifdef __MMFILE_FFMPEG_V085__
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("FFMPEG video codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("FFMPEG video codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
+#endif
AVPacket pkt = pFormatCtx->streams[i]->attached_pic;
- if((pkt.data != NULL) && (pkt.size > 0))
+ if ((pkt.data != NULL) && (pkt.size > 0))
continue;
- //eventhough codec_id is 0, avformat_find_stream_info() can find proper codec_id.
+ /*eventhough codec_id is 0, avformat_find_stream_info() can find proper codec_id. */
formatContext->videoTotalTrackNum += 1;
}
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("FFMPEG audio codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("FFMPEG audio codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
+#endif
formatContext->audioTotalTrackNum += 1;
}
#else
if (pFormatCtx->streams[i]->codec->codec_type == AV_CODEC_TYPE_VIDEO) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("FFMPEG video codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("FFMPEG video codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
+#endif
formatContext->videoTotalTrackNum += 1;
}
if (pFormatCtx->streams[i]->codec->codec_type == AV_CODEC_TYPE_AUDIO) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("FFMPEG audio codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("FFMPEG audio codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
+#endif
formatContext->audioTotalTrackNum += 1;
}
#endif
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("format: %s (%s)\n", pFormatCtx->iformat->name, pFormatCtx->iformat->long_name);
- #ifdef __MMFILE_FFMPEG_V085__
- av_dump_format (pFormatCtx, 0, formatContext->filesrc->file.path, 0);
- #else
- dump_format (pFormatCtx, 0, formatContext->filesrc->file.path, 0);
- #endif
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("format: %s (%s)\n", pFormatCtx->iformat->name, pFormatCtx->iformat->long_name);
+#ifdef __MMFILE_FFMPEG_V085__
+ av_dump_format(pFormatCtx, 0, formatContext->filesrc->file.path, 0);
+#else
+ dump_format(pFormatCtx, 0, formatContext->filesrc->file.path, 0);
+#endif
+#endif
return MMFILE_FORMAT_SUCCESS;
exception: /* fail to get content information */
- mmfile_format_close_ffmpg (formatContext);
+ mmfile_format_close_ffmpg(formatContext);
formatContext->privateFormatData = NULL;
return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_read_stream_ffmpg (MMFileFormatContext * formatContext)
+int mmfile_format_read_stream_ffmpg(MMFileFormatContext *formatContext)
{
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pAudioCodecCtx = NULL;
int ret = 0;
if (NULL == formatContext || NULL == formatContext->privateFormatData) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_FORMAT_FAIL;
}
*/
#ifdef __MMFILE_FFMPEG_V100__
if (formatContext->cdis != 1)
- ret = avformat_find_stream_info (pFormatCtx, NULL);
+ ret = avformat_find_stream_info(pFormatCtx, NULL);
else
ret = 0;
#else
- ret = av_find_stream_info (pFormatCtx);
+ ret = av_find_stream_info(pFormatCtx);
#endif
- if ( ret < 0 ) {
- debug_warning ("failed to find stream info. errcode = %d\n", ret);
+ if (ret < 0) {
+ debug_warning("failed to find stream info. errcode = %d\n", ret);
goto exception;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("FFMPEG: dur %lld, start %lld\n", pFormatCtx->duration, pFormatCtx->start_time);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("FFMPEG: dur %lld, start %lld\n", pFormatCtx->duration, pFormatCtx->start_time);
+#endif
/**
*@note asf has long duration bug. and Some content's start time is wrong(negative number).
*/
- if(pFormatCtx->start_time < 0) {
- debug_warning ("Wrong Start time = %lld\n", pFormatCtx->start_time);
+ if (pFormatCtx->start_time < 0) {
+ debug_warning("Wrong Start time = %lld\n", pFormatCtx->start_time);
formatContext->duration = (long long)(pFormatCtx->duration) * 1000 / AV_TIME_BASE;
- }
- else {
+ } else {
formatContext->duration = (long long)(pFormatCtx->duration + pFormatCtx->start_time) * 1000 / AV_TIME_BASE;
}
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 0;
- int i = 0;
- for ( i = 0; i < pFormatCtx->nb_streams; i++ ) {
+ unsigned int i = 0;
+ for (i = 0; i < pFormatCtx->nb_streams; i++) {
#ifdef __MMFILE_FFMPEG_V085__
- if ( pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+ if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
#else
if ( pFormatCtx->streams[i]->codec->codec_type == AV_CODEC_TYPE_VIDEO) {
#endif
if (formatContext->videoStreamId == -1) {
- videoStream = mmfile_malloc (sizeof(MMFileFormatStream));
+ videoStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == videoStream) {
- debug_error ("mmfile_malloc error\n");
+ debug_error("mmfile_malloc error\n");
goto exception;
}
pVideoCodecCtx = pFormatCtx->streams[i]->codec;
if (pVideoCodecCtx) {
- videoStream->codecId = ConvertVideoCodecEnum (pVideoCodecCtx->codec_id);
+ videoStream->codecId = ConvertVideoCodecEnum(pVideoCodecCtx->codec_id);
if (videoStream->codecId == MM_VIDEO_CODEC_NONE) {
debug_error("Proper codec is not found in [%d] stream", i);
formatContext->videoStreamId = -1;
* 1. try to get average fps of video stream.
* 2. if (1) failed, try to get fps of media container.
*/
- videoStream->framePerSec = _get_video_fps (pFormatCtx->streams[i]->nb_frames,
- pFormatCtx->streams[i]->duration,
- pFormatCtx->streams[i]->time_base,
- 1);
+ videoStream->framePerSec = _get_video_fps(pFormatCtx->streams[i]->nb_frames,
+ pFormatCtx->streams[i]->duration,
+ pFormatCtx->streams[i]->time_base,
+ 1);
if (videoStream->framePerSec == 0) {
#ifndef __MMFILE_LIBAV_VERSION__
- videoStream->framePerSec = av_q2d (pFormatCtx->streams[i]->r_frame_rate);
+ videoStream->framePerSec = av_q2d(pFormatCtx->streams[i]->r_frame_rate);
#else
- videoStream->framePerSec = av_q2d (pFormatCtx->streams[i]->avg_frame_rate);
+ videoStream->framePerSec = av_q2d(pFormatCtx->streams[i]->avg_frame_rate);
#endif
}
videoStream->bitRate = pVideoCodecCtx->bit_rate;
}
}
- }
+ }
#ifdef __MMFILE_FFMPEG_V085__
- else if ( pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO ) {
+ else if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
#else
else if ( pFormatCtx->streams[i]->codec->codec_type == AV_CODEC_TYPE_AUDIO ) {
#endif
if (formatContext->audioStreamId == -1) {
- audioStream = mmfile_malloc (sizeof(MMFileFormatStream));
+ audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error ("mmfile_malloc error\n");
+ debug_error("mmfile_malloc error\n");
goto exception;
}
pAudioCodecCtx = pFormatCtx->streams[i]->codec;
if (pAudioCodecCtx) {
- audioStream->codecId = ConvertAudioCodecEnum (pAudioCodecCtx->codec_id);
+ audioStream->codecId = ConvertAudioCodecEnum(pAudioCodecCtx->codec_id);
audioStream->bitRate = pAudioCodecCtx->bit_rate;
audioStream->nbChannel = pAudioCodecCtx->channels;
audioStream->samplePerSec = pAudioCodecCtx->sample_rate;
}
}
- if ( formatContext->nbStreams == 0 ) {
+ if (formatContext->nbStreams == 0) {
debug_error("error: there is no audio and video track\n");
goto exception;
}
- #ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ mmfile_format_print_contents(formatContext);
+#endif
return MMFILE_FORMAT_SUCCESS;
exception:
if (videoStream) {
- mmfile_free (videoStream);
+ mmfile_free(videoStream);
formatContext->streams[MMFILE_VIDEO_STREAM] = NULL;
}
if (audioStream) {
- mmfile_free (audioStream);
+ mmfile_free(audioStream);
formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
}
if (pFormatCtx) {
#ifdef __MMFILE_FFMPEG_V100__
- avformat_close_input (&pFormatCtx);
+ avformat_close_input(&pFormatCtx);
#else
- av_close_input_file (pFormatCtx);
+ av_close_input_file(pFormatCtx);
#endif
formatContext->privateFormatData = NULL;
}
#define DATA_LENGTH 4
#define POS_OF_MIME_LEN DATA_LENGTH
-#define CONVERT_TO_INT(dest, src) {dest = 0; dest |= (0 |src[0] << 24) | (0 | src[1] << 16) | (0 | src[2] << 8) | (0 | src[3]);}
+#define CONVERT_TO_INT(dest, src) {dest = 0; dest |= (0 | src[0] << 24) | (0 | src[1] << 16) | (0 | src[2] << 8) | (0 | src[3]);}
EXPORT_API
-int mmfile_format_read_tag_ffmpg (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_ffmpg(MMFileFormatContext *formatContext)
{
AVFormatContext *pFormatCtx = NULL;
if (NULL == formatContext || NULL == formatContext->privateFormatData) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_FORMAT_FAIL;
}
pFormatCtx = formatContext->privateFormatData;
- if (formatContext->formatType == MM_FILE_FORMAT_3GP ||formatContext->formatType == MM_FILE_FORMAT_MP4) {
- MMFileUtilGetMetaDataFromMP4 (formatContext);
+ if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
+ MMFileUtilGetMetaDataFromMP4(formatContext);
}
#ifdef __MMFILE_FFMPEG_V085__
-/*metadata extracted by ffmpeg*/
- int idx = 0;
+ /*metadata extracted by ffmpeg*/
+ unsigned int idx = 0;
- if(pFormatCtx != NULL) {
- for(idx = 0; idx < pFormatCtx->nb_streams + 1; idx++) {
+ if (pFormatCtx != NULL) {
+ for (idx = 0; idx < pFormatCtx->nb_streams + 1; idx++) {
AVDictionary *metainfo = NULL;
AVStream *st = NULL;
- if(idx < pFormatCtx->nb_streams) { //Check metadata of normal stream like audio, video, video cover art(cover art saved in new stream). refer to mov_read_covr() in ffmpeg.
+ if (idx < pFormatCtx->nb_streams) { /*Check metadata of normal stream like audio, video, video cover art(cover art saved in new stream). refer to mov_read_covr() in ffmpeg. */
st = pFormatCtx->streams[idx];
- if(st != NULL)
- metainfo = st->metadata;
- } else { //Check metadata of Content
- if(pFormatCtx->metadata != NULL) {
+ if (st != NULL)
+ metainfo = st->metadata;
+ } else { /*Check metadata of Content */
+ if (pFormatCtx->metadata != NULL) {
metainfo = pFormatCtx->metadata;
} else {
continue;
}
/*refer to mov_read_covr() in ffmpeg.*/
- if(st != NULL) {
+ if (st != NULL) {
AVPacket pkt = st->attached_pic;
int codec_id = st->codec->codec_id;
- if((pkt.data != NULL) && (pkt.size > 0)) {
+ if ((pkt.data != NULL) && (pkt.size > 0)) {
/*Set mime type*/
- if (formatContext->artworkMime) mmfile_free (formatContext->artworkMime);
+ if (formatContext->artworkMime) mmfile_free(formatContext->artworkMime);
- if(codec_id == AV_CODEC_ID_MJPEG)
+ if (codec_id == AV_CODEC_ID_MJPEG)
formatContext->artworkMime = mmfile_strdup("image/jpeg");
- else if(codec_id == AV_CODEC_ID_PNG)
+ else if (codec_id == AV_CODEC_ID_PNG)
formatContext->artworkMime = mmfile_strdup("image/png");
- else if(codec_id == AV_CODEC_ID_BMP)
+ else if (codec_id == AV_CODEC_ID_BMP)
formatContext->artworkMime = mmfile_strdup("image/bmp");
else
- debug_error ("Unknown cover type: 0x%x\n", codec_id);
+ debug_error("Unknown cover type: 0x%x\n", codec_id);
/*Copy artwork*/
- if (formatContext->artwork) mmfile_free (formatContext->artwork);
+ if (formatContext->artwork) mmfile_free(formatContext->artwork);
formatContext->artworkSize = pkt.size;
- formatContext->artwork = mmfile_malloc (pkt.size);
- memcpy (formatContext->artwork, pkt.data, pkt.size);
+ formatContext->artwork = mmfile_malloc(pkt.size);
+ if(formatContext->artwork != NULL)
+ memcpy(formatContext->artwork, pkt.data, pkt.size);
}
}
- if(metainfo != NULL) {
+ if (metainfo != NULL) {
AVDictionaryEntry *tag = NULL;
- while((tag=av_dict_get(metainfo, "", tag, AV_DICT_IGNORE_SUFFIX))) {
- if(tag->key != NULL) {
- if(!strcasecmp(tag->key, "title")) {
- if (formatContext->title) free (formatContext->title);
- formatContext->title = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "artist")) {
- if (formatContext->artist) free (formatContext->artist);
- formatContext->artist = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "composer")) {
- if (formatContext->composer) free (formatContext->composer);
- formatContext->composer = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "album")) {
- if (formatContext->album) free (formatContext->album);
- formatContext->album = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "album_artist")) {
- if (formatContext->album_artist) free (formatContext->album_artist);
- formatContext->album_artist = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "copyright")) {
- if (formatContext->copyright) free (formatContext->copyright);
- formatContext->copyright = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "comment")) {
- if (formatContext->comment) free (formatContext->comment);
- formatContext->comment = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "description")) {
- if (formatContext->description) free (formatContext->description);
- formatContext->description = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "genre")) {
- if (formatContext->genre) free (formatContext->genre);
- formatContext->genre = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "date")) {
- if (formatContext->year) free (formatContext->year);
- formatContext->year = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "creation_time")) {
- if (formatContext->recDate) free (formatContext->recDate);
- formatContext->recDate = mmfile_strdup (tag->value);
- } else if((!strcasecmp(tag->key, "track")) || (!strcasecmp(tag->key, "tracknumber"))) {
- if (formatContext->tagTrackNum) free (formatContext->tagTrackNum);
- formatContext->tagTrackNum = mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "lyrics")) {
- if (formatContext->unsyncLyrics) free (formatContext->unsyncLyrics);
- formatContext->unsyncLyrics= mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "rotate")) { //can be "90", "180", "270"
- if (formatContext->rotate) free (formatContext->rotate);
- formatContext->rotate= mmfile_strdup (tag->value);
- } else if(!strcasecmp(tag->key, "metadata_block_picture")) {
+ while ((tag = av_dict_get(metainfo, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+ if (tag->key != NULL) {
+ if (!strcasecmp(tag->key, "title")) {
+ if (formatContext->title) free(formatContext->title);
+ formatContext->title = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "artist")) {
+ if (formatContext->artist) free(formatContext->artist);
+ formatContext->artist = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "composer")) {
+ if (formatContext->composer) free(formatContext->composer);
+ formatContext->composer = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "album")) {
+ if (formatContext->album) free(formatContext->album);
+ formatContext->album = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "album_artist")) {
+ if (formatContext->album_artist) free(formatContext->album_artist);
+ formatContext->album_artist = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "copyright")) {
+ if (formatContext->copyright) free(formatContext->copyright);
+ formatContext->copyright = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "comment")) {
+ if (formatContext->comment) free(formatContext->comment);
+ formatContext->comment = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "description")) {
+ if (formatContext->description) free(formatContext->description);
+ formatContext->description = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "genre")) {
+ if (formatContext->genre) free(formatContext->genre);
+ formatContext->genre = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "date")) {
+ if (formatContext->year) free(formatContext->year);
+ formatContext->year = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "creation_time")) {
+ if (formatContext->recDate) free(formatContext->recDate);
+ formatContext->recDate = mmfile_strdup(tag->value);
+ } else if ((!strcasecmp(tag->key, "track")) || (!strcasecmp(tag->key, "tracknumber"))) {
+ if (formatContext->tagTrackNum) free(formatContext->tagTrackNum);
+ formatContext->tagTrackNum = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "lyrics")) {
+ if (formatContext->unsyncLyrics) free(formatContext->unsyncLyrics);
+ formatContext->unsyncLyrics = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "rotate")) { /*can be "90", "180", "270" */
+ if (formatContext->rotate) free(formatContext->rotate);
+ formatContext->rotate = mmfile_strdup(tag->value);
+ } else if (!strcasecmp(tag->key, "metadata_block_picture")) {
gsize len = 0;
guchar *meta_data = NULL;
/* set mime type */
current_pos = POS_OF_MIME_LEN + DATA_LENGTH; /*current position is mime type */
- if (formatContext->artworkMime) mmfile_free (formatContext->artworkMime);
- formatContext->artworkMime = strndup((const char*)meta_data + current_pos, mime_len);
+ if (formatContext->artworkMime) mmfile_free(formatContext->artworkMime);
+ formatContext->artworkMime = strndup((const char *)meta_data + current_pos, mime_len);
/* set art work data */
current_pos = mime_len + description_len + (DATA_LENGTH * 8); /*current position is picture data */
- if (formatContext->artwork) mmfile_free (formatContext->artwork);
+ if (formatContext->artwork) mmfile_free(formatContext->artwork);
- formatContext->artwork = mmfile_malloc (data_len);
- if(formatContext->artwork != NULL)
+ formatContext->artwork = mmfile_malloc(data_len);
+ if (formatContext->artwork != NULL)
memcpy(formatContext->artwork, meta_data + current_pos, data_len);
g_free(meta_data);
}
} else {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_log("Not support metadata. [%s:%s]", tag->key, tag->value);
- #endif
+#endif
}
}
}
}
#ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_tags (formatContext);
+ mmfile_format_print_tags(formatContext);
#endif
}
}
#else
if (pFormatCtx->title[0]) {
if (formatContext->title)
- free (formatContext->title);
- formatContext->title = mmfile_strdup (pFormatCtx->title);
+ free(formatContext->title);
+ formatContext->title = mmfile_strdup(pFormatCtx->title);
}
- if (pFormatCtx->author[0]){
+ if (pFormatCtx->author[0]) {
if (formatContext->author)
- free (formatContext->author);
- formatContext->author = mmfile_strdup (pFormatCtx->author);
+ free(formatContext->author);
+ formatContext->author = mmfile_strdup(pFormatCtx->author);
}
if (pFormatCtx->copyright[0]) {
if (formatContext->copyright)
- free (formatContext->copyright);
- formatContext->copyright = mmfile_strdup (pFormatCtx->copyright);
+ free(formatContext->copyright);
+ formatContext->copyright = mmfile_strdup(pFormatCtx->copyright);
}
if (pFormatCtx->comment[0]) {
if (formatContext->comment)
- free (formatContext->comment);
- formatContext->comment = mmfile_strdup (pFormatCtx->comment);
+ free(formatContext->comment);
+ formatContext->comment = mmfile_strdup(pFormatCtx->comment);
}
if (pFormatCtx->album[0]) {
if (formatContext->album)
- free (formatContext->album);
- formatContext->album = mmfile_strdup (pFormatCtx->album);
+ free(formatContext->album);
+ formatContext->album = mmfile_strdup(pFormatCtx->album);
}
if (pFormatCtx->genre[0]) {
if (formatContext->genre)
- free (formatContext->genre);
- formatContext->genre = mmfile_strdup (pFormatCtx->genre);
+ free(formatContext->genre);
+ formatContext->genre = mmfile_strdup(pFormatCtx->genre);
}
if (pFormatCtx->year) {
- char year[10] = {0,};
- snprintf (year, 10, "%d", pFormatCtx->year);
+ char year[10] = {0, };
+ snprintf(year, 10, "%d", pFormatCtx->year);
year[9] = '\0';
if (formatContext->year)
- free (formatContext->year);
- formatContext->year = mmfile_strdup (year);
+ free(formatContext->year);
+ formatContext->year = mmfile_strdup(year);
}
if (pFormatCtx->track) {
- char tracknum[10] = {0,};
- snprintf (tracknum, 10, "%d", pFormatCtx->track);
+ char tracknum[10] = {0, };
+ snprintf(tracknum, 10, "%d", pFormatCtx->track);
tracknum[9] = '\0';
if (formatContext->tagTrackNum)
- free (formatContext->tagTrackNum);
- formatContext->tagTrackNum = mmfile_strdup (tracknum);
+ free(formatContext->tagTrackNum);
+ formatContext->tagTrackNum = mmfile_strdup(tracknum);
}
#endif
EXPORT_API
-int mmfile_format_read_frame_ffmpg (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_ffmpg(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pVideoCodecCtx = NULL;
int ret = 0;
if (NULL == formatContext ||
- NULL == frame ||
- NULL == formatContext->privateFormatData ||
- formatContext->videoTotalTrackNum <= 0) {
+ NULL == frame ||
+ NULL == formatContext->privateFormatData ||
+ formatContext->videoTotalTrackNum <= 0) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->isdrm == MM_FILE_DRM_PROTECTED) {
- debug_error ("This is protected drm file\n");
+ debug_error("This is protected drm file\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->videoStreamId != -1) {
pVideoCodecCtx = pFormatCtx->streams[formatContext->videoStreamId]->codec;
if (NULL == pVideoCodecCtx) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_FORMAT_FAIL;
}
- pVideoCodec = avcodec_find_decoder (pVideoCodecCtx->codec_id);
- if ( NULL == pVideoCodec ) {
- debug_error ("error: avcodec_find_decoder failed\n");
+ pVideoCodec = avcodec_find_decoder(pVideoCodecCtx->codec_id);
+ if (NULL == pVideoCodec) {
+ debug_error("error: avcodec_find_decoder failed\n");
return MMFILE_FORMAT_FAIL;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("flag: 0x%08X\n", pVideoCodec->capabilities);
- // debug_msg (" DRAW_HORIZ_BAND : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND ? 1 : 0);
- // debug_msg (" DR1 : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_DR1 ? 1 : 0);
- // debug_msg (" PARSE_ONLY : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_PARSE_ONLY ? 1 : 0);
- // debug_msg (" TRUNCATED : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_TRUNCATED ? 1 : 0);
- // debug_msg (" HWACCEL : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_HWACCEL ? 1 : 0);
- // debug_msg (" DELAY : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_DELAY ? 1 : 0);
- // debug_msg (" SMALL_LAST_FRAME: %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME ? 1 : 0);
- // debug_msg (" HWACCEL_VDPAU : %d\n", pVideoCodec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU ? 1 : 0);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("flag: 0x%08X\n", pVideoCodec->capabilities);
+ /* debug_msg(" DRAW_HORIZ_BAND : %d\n", pVideoCodec->capabilities & CODEC_CAP_DRAW_HORIZ_BAND ? 1 : 0); */
+ /* debug_msg(" DR1 : %d\n", pVideoCodec->capabilities & CODEC_CAP_DR1 ? 1 : 0); */
+ /* debug_msg(" PARSE_ONLY : %d\n", pVideoCodec->capabilities & CODEC_CAP_PARSE_ONLY ? 1 : 0); */
+ /* debug_msg(" TRUNCATED : %d\n", pVideoCodec->capabilities & CODEC_CAP_TRUNCATED ? 1 : 0); */
+ /* debug_msg(" HWACCEL : %d\n", pVideoCodec->capabilities & CODEC_CAP_HWACCEL ? 1 : 0); */
+ /* debug_msg(" DELAY : %d\n", pVideoCodec->capabilities & CODEC_CAP_DELAY ? 1 : 0); */
+ /* debug_msg(" SMALL_LAST_FRAME: %d\n", pVideoCodec->capabilities & CODEC_CAP_SMALL_LAST_FRAME ? 1 : 0); */
+ /* debug_msg(" HWACCEL_VDPAU : %d\n", pVideoCodec->capabilities & CODEC_CAP_HWACCEL_VDPAU ? 1 : 0); */
+#endif
if (pVideoCodec->capabilities & CODEC_CAP_TRUNCATED) {
pVideoCodecCtx->flags |= CODEC_FLAG_TRUNCATED;
Thumbnail of video content is different with original file when copying file. */
pVideoCodecCtx->thread_type = 0;
pVideoCodecCtx->thread_count = 0;
- ret = avcodec_open2 (pVideoCodecCtx, pVideoCodec, NULL);
+ ret = avcodec_open2(pVideoCodecCtx, pVideoCodec, NULL);
#else
- ret = avcodec_open (pVideoCodecCtx, pVideoCodec);
+ ret = avcodec_open(pVideoCodecCtx, pVideoCodec);
#endif
if (ret < 0) {
- debug_error ("error: avcodec_open fail.\n");
+ debug_error("error: avcodec_open fail.\n");
return MMFILE_FORMAT_FAIL;
}
- pFrameRGB = avcodec_alloc_frame ();
+ pFrameRGB = av_frame_alloc();
if (!pFrameRGB) {
- debug_error ("error: pFrame or pFrameRGB is NULL\n");
+ debug_error("error: pFrame or pFrameRGB is NULL\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* search & decode */
- // seek_ts = formatContext->duration > _SHORT_MEDIA_LIMIT ? seek_ts : 0; /*if short media, seek first key frame*/
- ret = _get_first_good_video_frame (pFormatCtx, pVideoCodecCtx, formatContext->videoStreamId, &pFrame, formatContext->cdis);
- if ( ret != MMFILE_FORMAT_SUCCESS ) {
- debug_error ("error: get key frame\n");
+ /* seek_ts = formatContext->duration > _SHORT_MEDIA_LIMIT ? seek_ts : 0; */ /*if short media, seek first key frame*/
+ ret = _get_first_good_video_frame(pFormatCtx, pVideoCodecCtx, formatContext->videoStreamId, &pFrame, formatContext->cdis);
+ if (ret != MMFILE_FORMAT_SUCCESS) {
+ debug_error("error: get key frame\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Video default resolution = [%dx%d]\n", pVideoCodecCtx->coded_width, pVideoCodecCtx->coded_height);
- debug_msg ("Video coded resolution = [%dx%d]\n", pVideoCodecCtx->width, pVideoCodecCtx->height);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Video default resolution = [%dx%d]\n", pVideoCodecCtx->coded_width, pVideoCodecCtx->coded_height);
+ debug_msg("Video coded resolution = [%dx%d]\n", pVideoCodecCtx->width, pVideoCodecCtx->height);
+#endif
/*sometimes, ffmpeg's width/height is wrong*/
- #if 0 /*coded_width/height sometimes wrong. so use width/height*/
+#if 0 /*coded_width/height sometimes wrong. so use width/height*/
width = pVideoCodecCtx->coded_width == 0 ? pVideoCodecCtx->width : pVideoCodecCtx->coded_width;
height = pVideoCodecCtx->coded_height == 0 ? pVideoCodecCtx->height : pVideoCodecCtx->coded_height;
- #endif
- if((pVideoCodecCtx->width == 0) || (pVideoCodecCtx->height == 0)) {
+#endif
+ if ((pVideoCodecCtx->width == 0) || (pVideoCodecCtx->height == 0)) {
width = pVideoCodecCtx->coded_width;
height = pVideoCodecCtx->coded_height;
} else {
numBytes = avpicture_get_size(PIX_FMT_RGB24, width, height);
if (numBytes < 0) {
- debug_error ("error: avpicture_get_size. [%d x %d]\n", width, height);
+ debug_error("error: avpicture_get_size. [%d x %d]\n", width, height);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- frame->frameData = mmfile_malloc (numBytes);
+ frame->frameData = mmfile_malloc(numBytes);
if (NULL == frame->frameData) {
- debug_error ("error: avpicture_get_size. [%d]\n", numBytes);
+ debug_error("error: avpicture_get_size. [%d]\n", numBytes);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- ret = avpicture_fill ((AVPicture *)pFrameRGB, frame->frameData, PIX_FMT_RGB24, width, height);
+ ret = avpicture_fill((AVPicture *)pFrameRGB, frame->frameData, PIX_FMT_RGB24, width, height);
if (ret < 0) {
- debug_error ("error: avpicture_fill fail. errcode = 0x%08X\n", ret);
+ debug_error("error: avpicture_fill fail. errcode = 0x%08X\n", ret);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
#ifdef __MMFILE_FFMPEG_V085__
struct SwsContext *img_convert_ctx = NULL;
- img_convert_ctx = sws_getContext (width, height, pVideoCodecCtx->pix_fmt,
- width, height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
+ img_convert_ctx = sws_getContext(width, height, pVideoCodecCtx->pix_fmt,
+ width, height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
if (NULL == img_convert_ctx) {
- debug_error ("failed to get img convet ctx\n");
+ debug_error("failed to get img convet ctx\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- ret = sws_scale (img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize,
- 0, height, pFrameRGB->data, pFrameRGB->linesize);
- if ( ret < 0 ) {
- debug_error ("failed to convet image\n");
+ ret = sws_scale(img_convert_ctx, (const uint8_t * const *)pFrame->data, pFrame->linesize,
+ 0, height, pFrameRGB->data, pFrameRGB->linesize);
+ if (ret < 0) {
+ debug_error("failed to convet image\n");
ret = MMFILE_FORMAT_FAIL;
sws_freeContext(img_convert_ctx);
img_convert_ctx = NULL;
sws_freeContext(img_convert_ctx);
img_convert_ctx = NULL;
#else
- ret = img_convert ((AVPicture *)pFrameRGB, PIX_FMT_RGB24, (AVPicture*)pFrame, pVideoCodecCtx->pix_fmt, width, height);
- if ( ret < 0 ) {
- debug_error ("failed to convet image\n");
+ ret = img_convert((AVPicture *)pFrameRGB, PIX_FMT_RGB24, (AVPicture *)pFrame, pVideoCodecCtx->pix_fmt, width, height);
+ if (ret < 0) {
+ debug_error("failed to convet image\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
frame->configLenth = 0;
frame->bCompressed = 0; /* false */
- if (pFrame) av_free (pFrame);
- if (pFrameRGB) av_free (pFrameRGB);
+ if (pFrame) av_free(pFrame);
+ if (pFrameRGB) av_free(pFrameRGB);
avcodec_close(pVideoCodecCtx);
exception:
- if (pVideoCodecCtx) avcodec_close (pVideoCodecCtx);
- if (frame->frameData) { mmfile_free (frame->frameData); frame->frameData = NULL; }
- if (pFrame) av_free (pFrame);
- if (pFrameRGB) av_free (pFrameRGB);
+ if (pVideoCodecCtx) avcodec_close(pVideoCodecCtx);
+ if (frame->frameData) {
+ mmfile_free(frame->frameData);
+ frame->frameData = NULL;
+ }
+ if (pFrame) av_free(pFrame);
+ if (pFrameRGB) av_free(pFrameRGB);
return ret;
}
#ifdef __MMFILE_FFMPEG_V100__
avformat_close_input(&pFormatCtx);
#else
- av_close_input_file (pFormatCtx);
+ av_close_input_file(pFormatCtx);
#endif
formatContext->privateFormatData = NULL;
}
+
}
return MMFILE_FORMAT_SUCCESS;
/**
* return average of difference
*/
-static unsigned int _diff_memory (const void *s1, const void *s2, unsigned int n)
+static unsigned int _diff_memory(const void *s1, const void *s2, unsigned int n)
{
char *s = (char *)s1;
char *d = (char *)s2;
- int i;
- int ret;
+ unsigned int i;
+ unsigned int ret;
int tmp;
for (i = 0, ret = 0; i < n; i++) {
int64_t gettime(void)
{
struct timeval tv;
- gettimeofday(&tv,NULL);
+ gettimeofday(&tv, NULL);
return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
}
/**
* compare with center line.
*/
-static int _is_good_pgm (unsigned char *buf, int wrap, int xsize, int ysize)
+static int _is_good_pgm(unsigned char *buf, int wrap, int xsize, int ysize)
{
#define _MM_CHUNK_NUM 8 /*FIXME*/
#define _MM_CHUNK_LIMIT (_MM_CHUNK_NUM / 2)
cnt_offset = (ysize / 2);
cnt = buf + cnt_offset * wrap;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("checking frame. %p, %d, %d, %d\n", buf, wrap, xsize, ysize);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("checking frame. %p, %d, %d, %d\n", buf, wrap, xsize, ysize);
+#endif
/*if too small, always ok return.*/
if (ysize < _MM_CHUNK_NUM)
for (point = 0, sum_diff = 0, i = step; i < ysize; i += step) {
if (i != cnt_offset) {
-
+
/*binary compare*/
- is_different = _diff_memory (cnt, buf + i * wrap, xsize);
+ is_different = _diff_memory(cnt, buf + i * wrap, xsize);
point += (is_different == 0 ? 0 : 1);
sum_diff += is_different;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("check %04d line. %s [%d]\n", i, (is_different == 0 ? "same" : "different"), is_different);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("check %04d line. %s [%d]\n", i, (is_different == 0 ? "same" : "different"), is_different);
+#endif
if (point >= _MM_CHUNK_LIMIT) {
if (sum_diff > _MM_CHUNK_DIFF_LIMIT) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Good :-)\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Good :-)\n");
+#endif
return 1;
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Bad :-(\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Bad :-(\n");
+#endif
return 0;
}
}
}
return 0;
}
-#else // IS_GOOD_OLD_METHOD
+#else /* IS_GOOD_OLD_METHOD */
/* ToDo : for enhancement */
-#endif // IS_GOOD_OLD_METHOD
+#endif /* IS_GOOD_OLD_METHOD */
static int
-_get_video_fps (int frame_cnt, int duration, AVRational r_frame_rate, int is_roundup)
+_get_video_fps(int frame_cnt, int duration, AVRational r_frame_rate, int is_roundup)
{
double fps, round;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("frame count: %d, dur: %d, num: %d, den: %d\n", frame_cnt, duration, r_frame_rate.num, r_frame_rate.den);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("frame count: %d, dur: %d, num: %d, den: %d\n", frame_cnt, duration, r_frame_rate.num, r_frame_rate.den);
+#endif
if (duration <= 0 || r_frame_rate.num <= 0 || r_frame_rate.den <= 0)
return 0;
}
#ifdef MMFILE_FORMAT_DEBUG_DUMP
-static void _save_pgm (unsigned char *buf,int wrap, int xsize,int ysize,char *filename)
+static void _save_pgm(unsigned char *buf, int wrap, int xsize, int ysize, char *filename)
{
FILE *f;
int i;
- f = fopen(filename,"w");
+ f = fopen(filename, "w");
if (f) {
- fprintf (f,"P5\n%d %d\n%d\n",xsize,ysize,255);
+ fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
for (i = 0; i < ysize; i++)
- fwrite (buf + i * wrap, 1, xsize, f);
- fclose (f);
+ fwrite(buf + i * wrap, 1, xsize, f);
+ fclose(f);
}
}
#endif
#ifdef __MMFILE_TEST_MODE__
-static void _dump_av_packet (AVPacket *pkt)
+static void _dump_av_packet(AVPacket *pkt)
{
- debug_msg ("--------- AV Packet -----------\n");
- debug_msg (" pts: %lld\n", pkt->pts);
- debug_msg (" dts: %lld\n", pkt->dts);
- debug_msg (" data: %p\n", pkt->data);
- debug_msg (" size: %d\n", pkt->size);
- debug_msg (" stream_index: %d\n", pkt->stream_index);
-#ifdef __MMFILE_FFMPEG_V085__
- debug_msg (" flags: 0x%08X, %s\n", pkt->flags, (pkt->flags & AV_PKT_FLAG_KEY) ? "Keyframe" : "_");
+ debug_msg("--------- AV Packet -----------\n");
+ debug_msg(" pts: %lld\n", pkt->pts);
+ debug_msg(" dts: %lld\n", pkt->dts);
+ debug_msg(" data: %p\n", pkt->data);
+ debug_msg(" size: %d\n", pkt->size);
+ debug_msg(" stream_index: %d\n", pkt->stream_index);
+#ifdef __MMFILE_FFMPEG_V085__
+ debug_msg(" flags: 0x%08X, %s\n", pkt->flags, (pkt->flags & AV_PKT_FLAG_KEY) ? "Keyframe" : "_");
#else
- debug_msg (" flags: 0x%08X, %s\n", pkt->flags, (pkt->flags & PKT_FLAG_KEY) ? "Keyframe" : "_");
-#endif
- debug_msg (" duration: %d\n", pkt->duration);
- debug_msg (" destruct: %p\n", pkt->destruct);
- debug_msg (" priv: %p\n", pkt->priv);
- debug_msg (" pos: %lld\n", pkt->pos);
- debug_msg (" convergence_duration: %lld\n", pkt->convergence_duration);
- debug_msg ("-------------------------------\n");
+ debug_msg(" flags: 0x%08X, %s\n", pkt->flags, (pkt->flags & PKT_FLAG_KEY) ? "Keyframe" : "_");
+#endif
+ debug_msg(" duration: %d\n", pkt->duration);
+ debug_msg(" destruct: %p\n", pkt->destruct);
+ debug_msg(" priv: %p\n", pkt->priv);
+ debug_msg(" pos: %lld\n", pkt->pos);
+ debug_msg(" convergence_duration: %lld\n", pkt->convergence_duration);
+ debug_msg("-------------------------------\n");
}
#endif
-static int _get_first_good_video_frame (AVFormatContext *pFormatCtx, AVCodecContext *pCodecCtx, int videoStream, AVFrame **pFrame, int cdis)
+static int _get_first_good_video_frame(AVFormatContext *pFormatCtx, AVCodecContext *pCodecCtx, int videoStream, AVFrame **pFrame, int cdis)
{
- // AVStream *st = NULL;
+ /* AVStream *st = NULL; */
AVPacket pkt;
AVFrame *frame = NULL;
AVFrame *tmp_frame = NULL;
AVFrame *first_frame = NULL;
- // long long timestamp;
+ /* long long timestamp; */
int stream_id = videoStream;
int ret;
int found = 0;
- int i,v, len, got_picture;
+ int i, v, len, got_picture;
int retry = 0;
int key_detected;
#ifdef MMFILE_FORMAT_DEBUG_DUMP
- char pgm_name[256] = {0,};
+ char pgm_name[256] = {0, };
#endif
int key_search_limit = 0;
int frame_search_limit = 0;
#define _KEY_SEARCH_LIMIT_CDIS (_RETRY_SEARCH_LIMIT*2) /*2 = 1 read. some frame need to read one more*/
#define _FRAME_SEARCH_LIMIT_CDIS 10
- first_frame = avcodec_alloc_frame ();
- tmp_frame = avcodec_alloc_frame ();
+ first_frame = av_frame_alloc();
+ tmp_frame = av_frame_alloc();
if (!first_frame || !tmp_frame) {
- debug_error ("failed to alloc frame.\n");
- if (first_frame) av_free (first_frame);
- if (tmp_frame) av_free (tmp_frame);
+ debug_error("failed to alloc frame.\n");
+ if (first_frame) av_free(first_frame);
+ if (tmp_frame) av_free(tmp_frame);
return MMFILE_FORMAT_FAIL;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("frame: 1. %p, 2. %p\n", first_frame, tmp_frame);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("frame: 1. %p, 2. %p\n", first_frame, tmp_frame);
+#endif
#ifdef __MMFILE_FFMPEG_V085__
pCodecCtx->skip_frame = AVDISCARD_BIDIR;
frame_search_limit = _FRAME_SEARCH_LIMIT;
}
- for(i = 0, v = 0, key_detected = 0, frame = first_frame; i < key_search_limit && v < frame_search_limit;) {
- av_init_packet (&pkt);
+ for (i = 0, v = 0, key_detected = 0, frame = first_frame; i < key_search_limit && v < frame_search_limit;) {
+ av_init_packet(&pkt);
got_picture = 0;
- ret = av_read_frame (pFormatCtx, &pkt);
+ ret = av_read_frame(pFormatCtx, &pkt);
if (ret < 0) {
- debug_error ("read failed. (maybe EOF or broken)\n");
+ debug_error("read failed. (maybe EOF or broken)\n");
break;
} else {
if (pkt.stream_index == stream_id) {
v++;
-#ifdef __MMFILE_FFMPEG_V085__
- if ((pkt.flags & AV_PKT_FLAG_KEY ) || (key_detected == 1))
+#ifdef __MMFILE_FFMPEG_V085__
+ if ((pkt.flags & AV_PKT_FLAG_KEY) || (key_detected == 1))
#else
- if ((pkt.flags & PKT_FLAG_KEY ) || (key_detected == 1))
+ if ((pkt.flags & PKT_FLAG_KEY) || (key_detected == 1))
#endif
{
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("video frame: %d, %d, %d\n", retry, i, v);
- _dump_av_packet (&pkt);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("video frame: %d, %d, %d\n", retry, i, v);
+ _dump_av_packet(&pkt);
+#endif
i++;
key_detected = 0;
#ifdef __MMFILE_FFMPEG_V085__
- len = avcodec_decode_video2 (pCodecCtx, frame, &got_picture, &pkt);
+ len = avcodec_decode_video2(pCodecCtx, frame, &got_picture, &pkt);
#else
- len = avcodec_decode_video (pCodecCtx, frame, &got_picture, pkt.data, pkt.size);
+ len = avcodec_decode_video(pCodecCtx, frame, &got_picture, pkt.data, pkt.size);
#endif
if (len < 0) {
- debug_warning ("Error while decoding frame %dth\n", i);
+ debug_warning("Error while decoding frame %dth\n", i);
} else if (got_picture) {
if (frame->key_frame) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("key frame!\n");
- #endif
- #ifdef MMFILE_FORMAT_DEBUG_DUMP
- sprintf (pgm_name, "./key_%d_%d_%d.pgm", retry, i, v);
- _save_pgm (frame->data[0], frame->linesize[0], pCodecCtx->width, pCodecCtx->height, pgm_name);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("key frame!\n");
+#endif
+#ifdef MMFILE_FORMAT_DEBUG_DUMP
+ sprintf(pgm_name, "./key_%d_%d_%d.pgm", retry, i, v);
+ _save_pgm(frame->data[0], frame->linesize[0], pCodecCtx->width, pCodecCtx->height, pgm_name);
+#endif
found++;
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
int64_t ti;
ti = gettime();
- #endif
- ret = _is_good_pgm (frame->data[0], frame->linesize[0], pCodecCtx->width, pCodecCtx->height);
- #ifdef __MMFILE_TEST_MODE__
+#endif
+ ret = _is_good_pgm(frame->data[0], frame->linesize[0], pCodecCtx->width, pCodecCtx->height);
+#ifdef __MMFILE_TEST_MODE__
ti = gettime() - ti;
- debug_msg ("Elapsed time = %lld\n", ti);
- #endif
+ debug_msg("Elapsed time = %lld\n", ti);
+#endif
if (ret != 0) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("is good frame.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("is good frame.\n");
+#endif
break;
} else {
/*reset video frame count & retry searching*/
- #ifdef __MMFILE_TEST_MODE__
- debug_warning ("not good fame. retry scanning.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_warning("not good fame. retry scanning.\n");
+#endif
i = 0;
v = 0;
retry++;
if (retry > _RETRY_SEARCH_LIMIT) break;
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("skip (not key frame).\n");
- #endif
- #ifdef MMFILE_FORMAT_DEBUG_DUMP
- sprintf (pgm_name, "./not_key_%d_%d_%d.pgm", retry, i, v);
- _save_pgm (frame->data[0], frame->linesize[0], pCodecCtx->width, pCodecCtx->height, pgm_name);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("skip (not key frame).\n");
+#endif
+#ifdef MMFILE_FORMAT_DEBUG_DUMP
+ sprintf(pgm_name, "./not_key_%d_%d_%d.pgm", retry, i, v);
+ _save_pgm(frame->data[0], frame->linesize[0], pCodecCtx->width, pCodecCtx->height, pgm_name);
+#endif
}
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("decode not completed.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("decode not completed.\n");
+#endif
key_detected = 1;
}
}
}
}
- av_free_packet (&pkt);
+ av_free_packet(&pkt);
}
/*free pkt after loop breaking*/
- if (pkt.data) av_free_packet (&pkt);
+ if (pkt.data) av_free_packet(&pkt);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("found: %d, retry: %d\n", found, retry);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("found: %d, retry: %d\n", found, retry);
+#endif
/*set decode frame to output*/
if (found > 0) {
ret = MMFILE_FORMAT_SUCCESS;
if (retry == 0 || found == retry) {
*pFrame = first_frame;
- if (tmp_frame) av_free (tmp_frame);
+ if (tmp_frame) av_free(tmp_frame);
} else {
*pFrame = tmp_frame;
- if (first_frame) av_free (first_frame);
+ if (first_frame) av_free(first_frame);
}
} else {
ret = MMFILE_FORMAT_FAIL;
- if (first_frame) av_free (first_frame);
- if (tmp_frame) av_free (tmp_frame);
+ if (first_frame) av_free(first_frame);
+ if (tmp_frame) av_free(tmp_frame);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("out frame: %p\n", *pFrame);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("out frame: %p\n", *pFrame);
+#endif
#ifdef __MMFILE_FFMPEG_V085__
pCodecCtx->skip_frame = AVDISCARD_NONE;
return ret;
}
-static int ConvertVideoCodecEnum (int AVVideoCodecID)
+static int ConvertVideoCodecEnum(int AVVideoCodecID)
{
int ret_codecid = 0;
- switch (AVVideoCodecID)
- {
+ switch (AVVideoCodecID) {
case AV_CODEC_ID_NONE:
ret_codecid = MM_VIDEO_CODEC_NONE;
break;
case AV_CODEC_ID_MPEG1VIDEO:
ret_codecid = MM_VIDEO_CODEC_MPEG1;
break;
- case AV_CODEC_ID_MPEG2VIDEO: ///< preferred ID for MPEG-1/2 video decoding
+ case AV_CODEC_ID_MPEG2VIDEO: /*/< preferred ID for MPEG-1/2 video decoding */
case AV_CODEC_ID_MPEG2VIDEO_XVMC:
case AV_CODEC_ID_MPEG2TS:
ret_codecid = MM_VIDEO_CODEC_MPEG2;
ret_codecid = MM_VIDEO_CODEC_AVS;
break;
case AV_CODEC_ID_RL2:
- case AV_CODEC_ID_RV10: // RealVideo 1
- case AV_CODEC_ID_RV20: // RealVideo 2
- case AV_CODEC_ID_RV30: // RealVideo 3
- case AV_CODEC_ID_RV40: // RealVideo 4
+ case AV_CODEC_ID_RV10: /* RealVideo 1 */
+ case AV_CODEC_ID_RV20: /* RealVideo 2 */
+ case AV_CODEC_ID_RV30: /* RealVideo 3 */
+ case AV_CODEC_ID_RV40: /* RealVideo 4 */
ret_codecid = MM_VIDEO_CODEC_REAL;
break;
case AV_CODEC_ID_HEVC:
}
-static int ConvertAudioCodecEnum (int AVAudioCodecID)
+static int ConvertAudioCodecEnum(int AVAudioCodecID)
{
int ret_codecid = 0;
- switch (AVAudioCodecID)
- {
+ switch (AVAudioCodecID) {
case AV_CODEC_ID_AMR_NB:
case AV_CODEC_ID_AMR_WB:
ret_codecid = MM_AUDIO_CODEC_AMR;
break;
/* RealAudio codecs*/
- case AV_CODEC_ID_RA_144: // RealAudio 1
- case AV_CODEC_ID_RA_288: // RealAudio 2
- case AV_CODEC_ID_COOK: // RealAudio 6
+ case AV_CODEC_ID_RA_144: /* RealAudio 1 */
+ case AV_CODEC_ID_RA_288: /* RealAudio 2 */
+ case AV_CODEC_ID_COOK: /* RealAudio 6 */
ret_codecid = MM_AUDIO_CODEC_REAL;
break;
case AV_CODEC_ID_MP2:
{
int ret = 0; /*default: success*/
- switch(formatId) {
+ switch (formatId) {
case MM_FILE_FORMAT_3GP:
case MM_FILE_FORMAT_MP4:
snprintf(mimeType, buf_size, "video/3gpp");
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("id: %d, mimetype: %s\n", formatId, mimeType);
+ debug_msg("id: %d, mimetype: %s\n", formatId, mimeType);
#endif
return ret;
#include "mm_file_utils.h"
#include "mm_file_debug.h"
-typedef struct
-{
- DRM_DECRYPT_HANDLE hfile;
- long long offset;
- long long fsize;
+typedef struct {
+ DRM_DECRYPT_HANDLE hfile;
+ long long offset;
+ long long fsize;
} MMFileDRMHandle;
static int mmfile_drm_open(URLContext *h, const char *pseudofilename, int flags)
pseudofilename += strlen(h->prot->name) + 3; /* :// */
- ret = drm_is_drm_file (pseudofilename, &res);
- if (DRM_FALSE == res)
- {
- debug_error ("error: %s is not DRM file\n", pseudofilename);
+ ret = drm_is_drm_file(pseudofilename, &res);
+ if (DRM_FALSE == res) {
+ debug_error("error: %s is not DRM file\n", pseudofilename);
return -2;
}
- if(ret != DRM_RETURN_SUCCESS)
- {
- debug_error ("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
+ if (ret != DRM_RETURN_SUCCESS) {
+ debug_error("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
return -2;
}
/* Checks the DRM file type (supports only for OMA) if it is DRM */
ret = drm_get_file_type(pseudofilename, &file_type);
- if(ret != DRM_RETURN_SUCCESS)
- {
- debug_error ("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
+ if (ret != DRM_RETURN_SUCCESS) {
+ debug_error("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
return -2;
}
- if((file_type != DRM_TYPE_OMA_V1) && (file_type != DRM_TYPE_OMA_V2))
- {
- debug_error ("error: %s is not DRM file. file_type[%d]\n", pseudofilename, file_type);
+ if ((file_type != DRM_TYPE_OMA_V1) && (file_type != DRM_TYPE_OMA_V2)) {
+ debug_error("error: %s is not DRM file. file_type[%d]\n", pseudofilename, file_type);
return -2;
}
- drmHandle = mmfile_malloc (sizeof(MMFileDRMHandle));
- if (NULL == drmHandle)
- {
- debug_error ("error: mmfile_malloc\n");
+ drmHandle = mmfile_malloc(sizeof(MMFileDRMHandle));
+ if (NULL == drmHandle) {
+ debug_error("error: mmfile_malloc\n");
return -2;
}
memset(&open_output_data, 0x0, sizeof(drm_trusted_open_decrypt_resp_data_s));
memcpy(open_input_data.filePath, pseudofilename, strlen(pseudofilename));
- if(file_type == DRM_TYPE_OMA_V1) open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;
+ if (file_type == DRM_TYPE_OMA_V1) open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;
else open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V2;
open_input_data.permission = DRM_TRUSTED_PERMISSION_TYPE_DISPLAY;
- ret = drm_trusted_open_decrypt_session(&open_input_data,&open_output_data, &drmHandle->hfile);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_open_decrypt_session() [%x]\n", ret);
+ ret = drm_trusted_open_decrypt_session(&open_input_data, &open_output_data, &drmHandle->hfile);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_open_decrypt_session() [%x]\n", ret);
ret = -2;
goto exception;
}
seek_input_data.seek_mode = DRM_SEEK_END; /* Set cursor to end */
ret = drm_trusted_seek_decrypt_session(drmHandle->hfile, &seek_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
ret = -2;
goto exception;
}
/* Tell to get the file size */
memset(&tell_output_data, 0x0, sizeof(drm_trusted_tell_decrypt_resp_data_s));
ret = drm_trusted_tell_decrypt_session(drmHandle->hfile, &tell_output_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_tell_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_tell_decrypt_session() [%x]\n", ret);
ret = -2;
goto exception;
}
seek_input_data.seek_mode = DRM_SEEK_SET;
ret = drm_trusted_seek_decrypt_session(drmHandle->hfile, &seek_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
ret = -2;
goto exception;
}
h->max_packet_size = 0;
/* Set Consumption state*/
- memset(&state_input_data,0x0,sizeof(drm_trusted_set_consumption_state_info_s));
+ memset(&state_input_data, 0x0, sizeof(drm_trusted_set_consumption_state_info_s));
state_input_data.state = DRM_CONSUMPTION_PREVIEW;
ret = drm_trusted_set_decrypt_state(drmHandle->hfile, &state_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_set_decrypt_state [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_set_decrypt_state [%x]\n", ret);
ret = -2;
goto exception;
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ffmpeg drm open success==============\n");
+ debug_msg("ffmpeg drm open success==============\n");
#endif
return 0;
exception:
- if (drmHandle)
- {
- if (drmHandle->hfile)
- {
+ if (drmHandle) {
+ if (drmHandle->hfile) {
drm_trusted_close_decrypt_session(&drmHandle->hfile);
}
static int mmfile_drm_read(URLContext *h, unsigned char *buf, int size)
{
- //unsigned int readSize = 0;
+ /*unsigned int readSize = 0; */
MMFileDRMHandle *drmHandle = h->priv_data;
drm_trusted_payload_info_s read_input_data;
drm_trusted_read_decrypt_resp_data_s read_output_data;
int ret = 0;
- memset(&read_input_data,0x0,sizeof(drm_trusted_payload_info_s));
- memset(&read_output_data,0x0,sizeof(drm_trusted_read_decrypt_resp_data_s));
+ memset(&read_input_data, 0x0, sizeof(drm_trusted_payload_info_s));
+ memset(&read_output_data, 0x0, sizeof(drm_trusted_read_decrypt_resp_data_s));
read_input_data.payload_data = buf;
read_input_data.payload_data_len = (unsigned int)size;
read_input_data.payload_data_output = buf;
- if (drmHandle)
- {
+ if (drmHandle) {
ret = drm_trusted_read_decrypt_session(drmHandle->hfile, &read_input_data, &read_output_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_read_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_read_decrypt_session() [%x]\n", ret);
return -2;
}
drmHandle->offset += read_output_data.read_size;
static int mmfile_drm_write(URLContext *h, const unsigned char *buf, int size)
{
- debug_warning ("Permission Deny: DRM writing\n");
- return 0;
+ debug_warning("Permission Deny: DRM writing\n");
+ return 0;
}
static long long mmfile_drm_seek(URLContext *h, long long pos, int whence)
int ret = 0;
if (drmHandle) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("handle:%p, pos:%lld, whence:%d\n", h, pos, whence);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("handle:%p, pos:%lld, whence:%d\n", h, pos, whence);
+#endif
switch (whence) {
case SEEK_SET:
case AVSEEK_SIZE: /*FFMPEG specific*/
return drmHandle->fsize;
default:
- debug_error ("invalid whence[%d]\n", whence);
+ debug_error("invalid whence[%d]\n", whence);
return -2;
}
ret = drm_trusted_seek_decrypt_session(drmHandle->hfile, &seek_input_data);
if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
- debug_error ("error: drm_trusted_seek_decrypt_session() [%x] [mode=%d]\n", ret, drm_whence);
+ debug_error("error: drm_trusted_seek_decrypt_session() [%x] [mode=%d]\n", ret, drm_whence);
return -2;
}
return -1;
}
-static int mmfile_drm_close(URLContext* h)
+static int mmfile_drm_close(URLContext *h)
{
MMFileDRMHandle *drmHandle = NULL;
drm_trusted_set_consumption_state_info_s state_input_data;
int ret = 0;
- if (!h || !h->priv_data)
- {
- debug_error ("invalid para\n");
+ if (!h || !h->priv_data) {
+ debug_error("invalid para\n");
return MMFILE_UTIL_FAIL;
}
drmHandle = h->priv_data;
/* Set Consumption state*/
- memset(&state_input_data,0x0,sizeof(drm_trusted_set_consumption_state_info_s));
+ memset(&state_input_data, 0x0, sizeof(drm_trusted_set_consumption_state_info_s));
state_input_data.state = DRM_CONSUMPTION_STOPPED;
ret = drm_trusted_set_decrypt_state(drmHandle->hfile, &state_input_data);
- if(ret != DRM_TRUSTED_RETURN_SUCCESS) {
- debug_error ("error: drm_trusted_set_decrypt_state() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_set_decrypt_state() [%x]\n", ret);
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Success : drm_trusted_set_decrypt_state\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Success : drm_trusted_set_decrypt_state\n");
+#endif
}
- if (drmHandle)
- {
- if (drmHandle->hfile)
- {
+ if (drmHandle) {
+ if (drmHandle->hfile) {
ret = drm_trusted_close_decrypt_session(&drmHandle->hfile);
- if(ret != DRM_TRUSTED_RETURN_SUCCESS) {
- debug_error ("error: drm_trusted_close_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_close_decrypt_session() [%x]\n", ret);
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Success : drm_trusted_close_decrypt_session\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Success : drm_trusted_close_decrypt_session\n");
+#endif
}
drmHandle->hfile = NULL;
}
- mmfile_free (drmHandle);
+ mmfile_free(drmHandle);
h->priv_data = NULL;
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ffmpeg drm close success==============\n");
+ debug_msg("ffmpeg drm close success==============\n");
#endif
return 0;
int state;
} MMFmemIOHandle;
-static int mmf_mem_open (URLContext *handle, const char *filename, int flags)
+static int mmf_mem_open(URLContext *handle, const char *filename, int flags)
{
- MMFmemIOHandle *memHandle = NULL;
- char **splitedString = NULL;
-
-
- if (!handle || !filename || !handle->prot)
- {
- debug_error ("invalid param\n");
- return MMFILE_UTIL_FAIL;
- }
-
- filename += strlen(handle->prot->name) + 3; /* ://%d:%d means (memory addr:mem size)*/
-
- splitedString = mmfile_strsplit (filename, ":");
- if (splitedString == NULL)
- {
- debug_error ("invalid param\n");
- return MMFILE_UTIL_FAIL;
- }
-
- if (!splitedString[0] || !splitedString[1])
-
- {
- debug_error ("invalid param\n");
- goto exception;
- }
-
- memHandle = mmfile_malloc (sizeof(MMFmemIOHandle));
- if (!memHandle)
- {
- debug_error ("error: mmfile_malloc memHandle\n");
- goto exception;
- }
-
- memHandle->ptr = (unsigned char *) atoll(splitedString[0]); //memory allocation address changed. memHandle->ptr = (unsigned char *) atoi(splitedString[0]);
- memHandle->size = atoi(splitedString[1]);
- memHandle->offset = 0;
- memHandle->state = 0;
-
- handle->priv_data = (void*) memHandle;
-
- // Imp to reset them otherwise file seek will fail
- handle->is_streamed = 0; /*FALSE*/
- handle->max_packet_size = 0;
-
- if (splitedString)
- {
- mmfile_strfreev (splitedString);
- }
-
- return MMFILE_UTIL_SUCCESS;
+ MMFmemIOHandle *memHandle = NULL;
+ char **splitedString = NULL;
+
+
+ if (!handle || !filename || !handle->prot) {
+ debug_error("invalid param\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ filename += strlen(handle->prot->name) + 3; /* ://%d:%d means (memory addr:mem size)*/
+
+ splitedString = mmfile_strsplit(filename, ":");
+ if (splitedString == NULL) {
+ debug_error("invalid param\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ if (!splitedString[0] || !splitedString[1])
+
+ {
+ debug_error("invalid param\n");
+ goto exception;
+ }
+
+ memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
+ if (!memHandle) {
+ debug_error("error: mmfile_malloc memHandle\n");
+ goto exception;
+ }
+
+ memHandle->ptr = (unsigned char *)atoll(splitedString[0]); /*memory allocation address changed. memHandle->ptr = (unsigned char *) atoi(splitedString[0]); */
+ memHandle->size = atoi(splitedString[1]);
+ memHandle->offset = 0;
+ memHandle->state = 0;
+
+ handle->priv_data = (void *) memHandle;
+
+ /* Imp to reset them otherwise file seek will fail */
+ handle->is_streamed = 0; /*FALSE*/
+ handle->max_packet_size = 0;
+
+ if (splitedString) {
+ mmfile_strfreev(splitedString);
+ }
+
+ return MMFILE_UTIL_SUCCESS;
exception:
- if (splitedString)
- {
- mmfile_strfreev (splitedString);
- }
-
-#if 0 //dead code
- if (memHandle)
- {
- mmfile_free (memHandle);
- handle->priv_data = NULL;
- }
+ if (splitedString) {
+ mmfile_strfreev(splitedString);
+ }
+
+#if 0 /*dead code */
+ if (memHandle) {
+ mmfile_free(memHandle);
+ handle->priv_data = NULL;
+ }
#endif
- return MMFILE_UTIL_FAIL;
+ return MMFILE_UTIL_FAIL;
}
-static int mmf_mem_read (URLContext *h, unsigned char *buf, int size)
+static int mmf_mem_read(URLContext *h, unsigned char *buf, int size)
{
- MMFmemIOHandle *memHandle = NULL;
- const unsigned char *c = NULL;
- int len = 0;
+ MMFmemIOHandle *memHandle = NULL;
+ const unsigned char *c = NULL;
+ int len = 0;
+
-
- if (!h || !h->priv_data || !buf)
- {
- debug_error ("invalid para\n");
- return MMFILE_UTIL_FAIL;
- }
+ if (!h || !h->priv_data || !buf) {
+ debug_error("invalid para\n");
+ return MMFILE_UTIL_FAIL;
+ }
- memHandle = h->priv_data;
+ memHandle = h->priv_data;
- if (!memHandle->ptr)
- {
- debug_error ("invalid para\n");
- return MMFILE_UTIL_FAIL;
- }
+ if (!memHandle->ptr) {
+ debug_error("invalid para\n");
+ return MMFILE_UTIL_FAIL;
+ }
if (memHandle->offset >= memHandle->size) {
- // for some file formats last file read
- debug_error ("File Read is beyond the file Size\n");
+ /* for some file formats last file read */
+ debug_error("File Read is beyond the file Size\n");
return MMFILE_UTIL_FAIL;
-
- }
-
- c = memHandle->ptr + memHandle->offset;
-
- if (memHandle->state != EOF)
- {
- len = size;
- if (len + memHandle->offset > memHandle->size)
- {
- len = memHandle->size - memHandle->offset;
- }
- }
-
- memcpy (buf, c, len);
-
- memHandle->offset += len;
-
- if ( memHandle->offset == memHandle->size)
- {
- memHandle->state = EOF;
- }
-
- return len;
+
+ }
+
+ c = memHandle->ptr + memHandle->offset;
+
+ if (memHandle->state != EOF) {
+ len = size;
+ if (len + memHandle->offset > memHandle->size) {
+ len = memHandle->size - memHandle->offset;
+ }
+ }
+
+ memcpy(buf, c, len);
+
+ memHandle->offset += len;
+
+ if (memHandle->offset == memHandle->size) {
+ memHandle->state = EOF;
+ }
+
+ return len;
}
-static int mmf_mem_write (URLContext *h, unsigned char *buf, int size)
+static int mmf_mem_write(URLContext *h, const unsigned char *buf, int size)
{
- if (!h || !h->priv_data || !buf)
- {
- debug_error ("invalid para\n");
- return MMFILE_UTIL_FAIL;
- }
-
- debug_error ("NOTE PERMITTED\n");
- return MMFILE_UTIL_FAIL;
+ if (!h || !h->priv_data || !buf) {
+ debug_error("invalid para\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ debug_error("NOTE PERMITTED\n");
+ return MMFILE_UTIL_FAIL;
}
-static long long mmf_mem_seek (URLContext *h, long long pos, int whence)
+static long long mmf_mem_seek(URLContext *h, long long pos, int whence)
{
- MMFmemIOHandle *memHandle = NULL;
- long long tmp_offset = 0;
-
-
- if (!h || !h->priv_data)
- {
- debug_error ("invalid para\n");
- return MMFILE_UTIL_FAIL;
- }
-
- memHandle = h->priv_data;
-
- switch (whence)
- {
- case SEEK_SET:
- tmp_offset = 0 + pos;
- break;
- case SEEK_CUR:
- tmp_offset = memHandle->offset + pos;
- break;
- case SEEK_END:
- tmp_offset = memHandle->size + pos;
- break;
- case AVSEEK_SIZE: /*FFMPEG specific*/
- return memHandle->size;
- default:
- return MMFILE_UTIL_FAIL;
- }
-
- /*check validation*/
- if (tmp_offset < 0 && tmp_offset > memHandle->size)
- {
- debug_error ("invalid file offset\n");
- return MMFILE_UTIL_FAIL;
- }
-
- /*set */
- memHandle->state = (tmp_offset >= memHandle->size) ? EOF : !EOF;
- memHandle->offset = (unsigned int) tmp_offset;
-
- return tmp_offset;
+ MMFmemIOHandle *memHandle = NULL;
+ long long tmp_offset = 0;
+
+
+ if (!h || !h->priv_data) {
+ debug_error("invalid para\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ memHandle = h->priv_data;
+
+ switch (whence) {
+ case SEEK_SET:
+ tmp_offset = 0 + pos;
+ break;
+ case SEEK_CUR:
+ tmp_offset = memHandle->offset + pos;
+ break;
+ case SEEK_END:
+ tmp_offset = memHandle->size + pos;
+ break;
+ case AVSEEK_SIZE: /*FFMPEG specific*/
+ return memHandle->size;
+ default:
+ return MMFILE_UTIL_FAIL;
+ }
+
+ /*check validation*/
+ if (tmp_offset < 0 && tmp_offset > memHandle->size) {
+ debug_error("invalid file offset\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ /*set */
+ memHandle->state = (tmp_offset >= memHandle->size) ? EOF : !EOF;
+ memHandle->offset = (unsigned int) tmp_offset;
+
+ return tmp_offset;
}
-static int mmf_mem_close (URLContext *h)
+static int mmf_mem_close(URLContext *h)
{
- MMFmemIOHandle *memHandle = NULL;
+ MMFmemIOHandle *memHandle = NULL;
- if (!h || !h->priv_data)
- {
- debug_error ("invalid para\n");
- return MMFILE_UTIL_FAIL;
- }
+ if (!h || !h->priv_data) {
+ debug_error("invalid para\n");
+ return MMFILE_UTIL_FAIL;
+ }
- memHandle = h->priv_data;
+ memHandle = h->priv_data;
- if (memHandle)
- {
- mmfile_free (memHandle);
- h->priv_data = NULL;
- }
+ if (memHandle) {
+ mmfile_free(memHandle);
+ h->priv_data = NULL;
+ }
- return MMFILE_UTIL_SUCCESS;
+ return MMFILE_UTIL_SUCCESS;
}
URLProtocol MMFileMEMProtocol = {
- .name = "mem",
- .url_open = mmf_mem_open,
- .url_read = mmf_mem_read,
- .url_write = mmf_mem_write,
- .url_seek = mmf_mem_seek,
- .url_close = mmf_mem_close,
+ .name = "mem",
+ .url_open = mmf_mem_open,
+ .url_read = mmf_mem_read,
+ .url_write = mmf_mem_write,
+ .url_seek = mmf_mem_seek,
+ .url_close = mmf_mem_close,
};
#ifdef MMFILE_FORMAT_DEBUG_DUMP
static void __save_frame(AVFrame *pFrame, int width, int height, int iFrame);
-void __save_frame(AVFrame *pFrame, int width, int height, int iFrame) {
+void __save_frame(AVFrame *pFrame, int width, int height, int iFrame)
+{
FILE *pFile;
char szFilename[32];
int y;
- // Open file
+ /* Open file */
sprintf(szFilename, "frame%d.ppm", iFrame);
- pFile=fopen(szFilename, "wb");
- if(pFile==NULL)
+ pFile = fopen(szFilename, "wb");
+ if (pFile == NULL)
return;
- // Write header
+ /* Write header */
fprintf(pFile, "P6\n%d %d\n255\n", width, height);
- // Write pixel data
- for(y=0; y<height; y++)
- fwrite(pFrame->data[0]+y*pFrame->linesize[0], 1, width*3, pFile);
+ /* Write pixel data */
+ for (y = 0; y < height; y++)
+ fwrite(pFrame->data[0] + y * pFrame->linesize[0], 1, width * 3, pFile);
- // Close file
+ /* Close file */
fclose(pFile);
}
#endif
{
int ret = 0; /*default: success*/
- switch(formatId) {
+ switch (formatId) {
case MM_FILE_FORMAT_3GP:
case MM_FILE_FORMAT_MP4:
snprintf(mimeType, buf_size, "video/3gpp");
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("id: %d, mimetype: %s\n", formatId, mimeType);
+ debug_msg("id: %d, mimetype: %s\n", formatId, mimeType);
#endif
return ret;
debug_error("%s\n", urifilename);
- ret = mmfile_open (&fp, urifilename, MMFILE_RDONLY);
+ ret = mmfile_open(&fp, urifilename, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
- if(fp)
+ debug_error("error: mmfile_open\n");
+ if (fp)
mmfile_close(fp);
return MMFILE_FORMAT_FAIL;
}
for (index = 0; index < MM_FILE_FORMAT_NUM; index++) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("search index = [%d]\n", index);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("search index = [%d]\n", index);
+#endif
switch (index) {
case MM_FILE_FORMAT_QT:
case MM_FILE_FORMAT_3GP:
case MM_FILE_FORMAT_MP4: {
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*format = MM_FILE_FORMAT_3GP;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_ASF:
case MM_FILE_FORMAT_WMA:
case MM_FILE_FORMAT_WMV: {
- if (MMFileFormatIsValidASF (fp, NULL)) {
+ if (MMFileFormatIsValidASF(fp, NULL)) {
*format = MM_FILE_FORMAT_ASF;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_MATROSKA: {
- if (MMFileFormatIsValidMatroska (fp, NULL)) {
+ if (MMFileFormatIsValidMatroska(fp, NULL)) {
*format = MM_FILE_FORMAT_MATROSKA;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_FLV: {
- if (MMFileFormatIsValidFLV (fp, NULL)) {
+ if (MMFileFormatIsValidFLV(fp, NULL)) {
*format = MM_FILE_FORMAT_FLV;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_REAL: {
- if (MMFileFormatIsValidREAL (fp, NULL)) {
+ if (MMFileFormatIsValidREAL(fp, NULL)) {
*format = MM_FILE_FORMAT_REAL;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_M1AUDIO: {
- if (MMFileFormatIsValidMPEGAUDIO (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGAUDIO(fp, NULL)) {
*format = MM_FILE_FORMAT_M1AUDIO;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_M1VIDEO: {
- if (MMFileFormatIsValidMPEGVIDEO (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
*format = MM_FILE_FORMAT_M1VIDEO;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_JPG:
break;
default: {
- debug_error ("error: invaild format enum[%d]\n", index);
+ debug_error("error: invaild format enum[%d]\n", index);
break;
}
}
*format = -1;
- if(fp)
+ if (fp)
mmfile_close(fp);
return MMFILE_FORMAT_FAIL;
FILE_FORMAT_SUCCESS:
- if(fp)
+ if (fp)
mmfile_close(fp);
return MMFILE_FORMAT_SUCCESS;
static int __mmfile_get_frame(AVFormatContext *pFormatCtx, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
- int i = 0;
+ unsigned int i = 0;
int len = 0;
int ret = MMFILE_FORMAT_SUCCESS;
int videoStream = -1;
/* Retrieve stream information */
#ifdef __MMFILE_FFMPEG_V100__
- if(avformat_find_stream_info(pFormatCtx, NULL) < 0) {
+ if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
#else
- if(av_find_stream_info(pFormatCtx) < 0) {
+ if (av_find_stream_info(pFormatCtx) < 0) {
#endif
debug_error("error : av_find_stream_info failed");
ret = MMFILE_FORMAT_FAIL;
}
/* Find the first video stream */
- for(i = 0; i < pFormatCtx->nb_streams; i++) {
- if(pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+ for (i = 0; i < pFormatCtx->nb_streams; i++) {
+ if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
break;
}
}
- if(videoStream == -1) {
+ if (videoStream == -1) {
debug_error("error : videoStream == -1");
ret = MMFILE_FORMAT_FAIL;
goto exception; /* Didn't find a video stream */
}
/* Get a pointer to the codec context for the video stream */
- pVideoCodecCtx=pFormatCtx->streams[videoStream]->codec;
+ pVideoCodecCtx = pFormatCtx->streams[videoStream]->codec;
if (pVideoCodecCtx == NULL) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* Find the decoder for the video stream */
pVideoCodec = avcodec_find_decoder(pVideoCodecCtx->codec_id);
- if(pVideoCodec == NULL) {
+ if (pVideoCodec == NULL) {
debug_error("error : Unsupported codec");
ret = MMFILE_FORMAT_FAIL;
goto exception; /* Codec not found */
#ifdef __MMFILE_FFMPEG_V100__
pVideoCodecCtx->thread_type = 0;
pVideoCodecCtx->thread_count = 0;
- if(avcodec_open2(pVideoCodecCtx, pVideoCodec, NULL) < 0) {
+ if (avcodec_open2(pVideoCodecCtx, pVideoCodec, NULL) < 0) {
#else
- if(avcodec_open(pVideoCodecCtx, pVideoCodec) < 0) {
+ if (avcodec_open(pVideoCodecCtx, pVideoCodec) < 0) {
#endif
debug_error("error : avcodec_open failed");
ret = MMFILE_FORMAT_FAIL;
/* Storing Data */
/* Allocate video frame */
- pFrame = avcodec_alloc_frame();
- if(pFrame == NULL) {
- debug_error ("error: pFrame is NULL\n");
+ pFrame = av_frame_alloc();
+ if (pFrame == NULL) {
+ debug_error("error: pFrame is NULL\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* Allocate an AVFrame structure */
- pFrameRGB = avcodec_alloc_frame();
- if(pFrameRGB == NULL) {
- debug_error ("error: pFrameRGB is NULL\n");
+ pFrameRGB = av_frame_alloc();
+ if (pFrameRGB == NULL) {
+ debug_error("error: pFrameRGB is NULL\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
}
#endif
duration = duration * MILLION;
- if ((duration <= 0) ||(duration <= pos)) {
+ if ((duration <= 0) || (duration <= pos)) {
debug_error("duration error duration[%f] pos[%f]", duration, pos);
ret = MMFILE_FORMAT_FAIL;
goto exception;
av_init_packet(&packet);
- while(av_read_frame(pFormatCtx, &packet) >= 0) {
+ while (av_read_frame(pFormatCtx, &packet) >= 0) {
got_picture = 0;
- // Is this a packet from the video stream?
- if(packet.stream_index == videoStream) {
+ /* Is this a packet from the video stream? */
+ if (packet.stream_index == videoStream) {
#ifdef __MMFILE_TEST_MODE__
debug_msg("find Video Stream+++++++[%2d]", idx++);
#endif
/* Decode video frame*/
len = avcodec_decode_video2(pVideoCodecCtx, pFrame, &got_picture, &packet);
if (len < 0) {
- debug_warning ("Error while decoding frame");
+ debug_warning("Error while decoding frame");
} else if ((packet.flags & AV_PKT_FLAG_KEY) || (key_detected == 1)) {
key_detected = 0;
Go back to previousto Key frame and decode frame until time stamp's frame*/
if (got_picture) {
- if(pFrame->key_frame) {
- #ifdef __MMFILE_TEST_MODE__
+ if (pFrame->key_frame) {
+#ifdef __MMFILE_TEST_MODE__
debug_msg("find Video Stream+++++++Find key frame");
- #endif
+#endif
} else {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("find Video Stream+++++++ not key frame");
- #endif
+#endif
}
/*eventhough decoded pFrame is not key frame, if packet.flags is AV_PKT_FLAG_KEY then can extract frame*/
find = true;
} else {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("find Video Stream+++++++Find key but no frame");
- #endif
+#endif
key_detected = 1;
}
}
} else {
- if(is_accurate) {
+ if (is_accurate) {
if (first_seek) {
- pts = (packet.pts == AV_NOPTS_VALUE) ? (packet.dts * av_q2d(pStream->time_base)) : packet.pts;
+ pts = (packet.pts == (int64_t)AV_NOPTS_VALUE) ? (packet.dts * av_q2d(pStream->time_base)) : packet.pts;
first_seek = false;
av_seek_frame(pFormatCtx, -1, pos, AVSEEK_FLAG_BACKWARD);
} else {
- tmpPts = (packet.pts == AV_NOPTS_VALUE) ? (packet.dts * av_q2d(pStream->time_base)) : packet.pts;
+ tmpPts = (packet.pts == (int64_t)AV_NOPTS_VALUE) ? (packet.dts * av_q2d(pStream->time_base)) : packet.pts;
if (pts == tmpPts)
find = true;
}
}
}
- if(find && got_picture) {
+ if (find && got_picture) {
break;
}
}
}
/*free pkt after loop breaking*/
- av_free_packet (&packet);
+ av_free_packet(&packet);
/* Did we get a video frame?*/
- if(got_picture && find) {
+ if (got_picture && find) {
#ifdef __MMFILE_TEST_MODE__
debug_msg("Find Frame");
#endif
/* return frame infromations*/
- if((pVideoCodecCtx->width == 0) || (pVideoCodecCtx->height == 0)) {
+ if ((pVideoCodecCtx->width == 0) || (pVideoCodecCtx->height == 0)) {
*width = pVideoCodecCtx->coded_width;
*height = pVideoCodecCtx->coded_height;
} else {
}
*size = avpicture_get_size(PIX_FMT_RGB24, *width, *height);
- *frame = mmfile_malloc (*size);
+
+ if (*size > 0)
+ *frame = mmfile_malloc(*size);
+
if (NULL == *frame) {
- debug_error ("error: avpicture_get_size. [%d]\n", size);
+ debug_error("error: avpicture_get_size. [%d]\n", size);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
debug_msg("height : %d", *height);
debug_msg("frame : %x", *frame);
#endif
- ret = avpicture_fill ((AVPicture *)pFrameRGB, *frame, PIX_FMT_RGB24, *width, *height);
+ ret = avpicture_fill((AVPicture *)pFrameRGB, *frame, PIX_FMT_RGB24, *width, *height);
if (ret < 0) {
- debug_error ("error: avpicture_fill fail. errcode = 0x%08X\n", ret);
+ debug_error("error: avpicture_fill fail. errcode = 0x%08X\n", ret);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
#ifdef __MMFILE_FFMPEG_V085__
struct SwsContext *img_convert_ctx = NULL;
- img_convert_ctx = sws_getContext (*width, *height, pVideoCodecCtx->pix_fmt,
- *width, *height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
+ img_convert_ctx = sws_getContext(*width, *height, pVideoCodecCtx->pix_fmt,
+ *width, *height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
if (NULL == img_convert_ctx) {
- debug_error ("failed to get img convet ctx\n");
+ debug_error("failed to get img convet ctx\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- ret = sws_scale (img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize,
- 0, *height, pFrameRGB->data, pFrameRGB->linesize);
- if ( ret < 0 ) {
- debug_error ("failed to convet image\n");
+ ret = sws_scale(img_convert_ctx, (const uint8_t * const *)pFrame->data, pFrame->linesize,
+ 0, *height, pFrameRGB->data, pFrameRGB->linesize);
+ if (ret < 0) {
+ debug_error("failed to convet image\n");
sws_freeContext(img_convert_ctx);
img_convert_ctx = NULL;
ret = MMFILE_FORMAT_FAIL;
sws_freeContext(img_convert_ctx);
img_convert_ctx = NULL;
#else
- ret = img_convert ((AVPicture *)pFrameRGB, PIX_FMT_RGB24, (AVPicture*)pFrame, pVideoCodecCtx->pix_fmt, *width, *height);
- if ( ret < 0 ) {
- debug_error ("failed to convet image\n");
+ ret = img_convert((AVPicture *)pFrameRGB, PIX_FMT_RGB24, (AVPicture *)pFrame, pVideoCodecCtx->pix_fmt, *width, *height);
+ if (ret < 0) {
+ debug_error("failed to convet image\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
#endif
#ifdef MMFILE_FORMAT_DEBUG_DUMP
- __save_frame(pFrameRGB, pVideoCodecCtx->width, pVideoCodecCtx->height, (int)(pos/1000));
+ __save_frame(pFrameRGB, pVideoCodecCtx->width, pVideoCodecCtx->height, (int)(pos / 1000));
#endif
- }
- else
- {
+ } else {
debug_error("Not Found Proper Frame[%d][%d]", got_picture, find);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- if (pFrame) av_free (pFrame);
- if (pFrameRGB) av_free (pFrameRGB);
+ if (pFrame) av_free(pFrame);
+ if (pFrameRGB) av_free(pFrameRGB);
if (pVideoCodecCtx) avcodec_close(pVideoCodecCtx);
return MMFILE_FORMAT_SUCCESS;
exception:
- if (*frame) { mmfile_free (*frame); *frame = NULL; }
- if (pFrame) av_free (pFrame);
- if (pFrameRGB) av_free (pFrameRGB);
- if (pVideoCodecCtx) avcodec_close (pVideoCodecCtx);
+ if (*frame) {
+ mmfile_free(*frame);
+ *frame = NULL;
+ }
+ if (pFrame) av_free(pFrame);
+ if (pFrameRGB) av_free(pFrameRGB);
+ if (pVideoCodecCtx) avcodec_close(pVideoCodecCtx);
return ret;
}
-int mmfile_format_get_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
+int mmfile_format_get_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
int ret = MMFILE_FORMAT_SUCCESS;
AVFormatContext *pFormatCtx = NULL;
#ifdef DRM_SUPPORT
drm_bool_type_e res = DRM_FALSE;
- ret = drm_is_drm_file (path, &res);
- if (DRM_TRUE == res)
- {
- debug_error ("Not support DRM Contents\n");
+ ret = drm_is_drm_file(path, &res);
+ if (DRM_TRUE == res) {
+ debug_error("Not support DRM Contents\n");
return MMFILE_FORMAT_FAIL;
}
#endif
av_register_all();
/* Open video file */
- if(avformat_open_input(&pFormatCtx, path, NULL, NULL) != 0) {
+ if (avformat_open_input(&pFormatCtx, path, NULL, NULL) != 0) {
debug_error("error : avformat_open_input failed");
return MMFILE_FORMAT_FAIL; /* Couldn't open file */
}
if (!pFormatCtx) {
- debug_warning ("failed to find av stream. maybe corrupted data.\n");
+ debug_warning("failed to find av stream. maybe corrupted data.\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
if (pFormatCtx) avformat_close_input(&pFormatCtx);
return ret;
- }
+}
int mmfile_format_get_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
int ret = MMFILE_FORMAT_SUCCESS;
int format = -1;
- char mimeType[MMFILE_MIMETYPE_MAX_LEN] = {0,};
- char ffmpegFormatName[MMFILE_FILE_FMT_MAX_LEN] = {0,};
- char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0,};
+ char mimeType[MMFILE_MIMETYPE_MAX_LEN] = {0, };
+ char ffmpegFormatName[MMFILE_FILE_FMT_MAX_LEN] = {0, };
+ char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0, };
char *urifilename = NULL;
AVFormatContext *pFormatCtx = NULL;
AVInputFormat *grab_iformat = NULL;
av_register_all();
- snprintf (tempURIBuffer, MMFILE_URI_MAX_LEN, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)data, datasize);
- urifilename = mmfile_strdup (tempURIBuffer);
+ snprintf(tempURIBuffer, MMFILE_URI_MAX_LEN, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)data, datasize);
+ urifilename = mmfile_strdup(tempURIBuffer);
if (!urifilename) {
- debug_error ("error: uri is NULL\n");
+ debug_error("error: uri is NULL\n");
return MMFILE_FORMAT_FAIL;
}
ret = __get_fileformat(urifilename, &format);
if (ret != MMFILE_FORMAT_SUCCESS) {
- debug_error ("error: file format is invalid\n");
+ debug_error("error: file format is invalid\n");
return MMFILE_FORMAT_FAIL;
}
-#if (defined __MMFILE_FFMPEG_V085__ && ! defined __MMFILE_LIBAV_VERSION__)
- ffurl_register_protocol(&MMFileMEMProtocol, sizeof (URLProtocol));
+#if (defined __MMFILE_FFMPEG_V085__ && !defined __MMFILE_LIBAV_VERSION__)
+ ffurl_register_protocol(&MMFileMEMProtocol, sizeof(URLProtocol));
#else
- register_protocol (&MMFileMEMProtocol);
+ ffurl_register_protocol(&MMFileMEMProtocol);
#endif
- if(__getMimeType(format, mimeType, MMFILE_MIMETYPE_MAX_LEN)< 0) {
- debug_error ("error: Error in MIME Type finding\n");
+ if (__getMimeType(format, mimeType, MMFILE_MIMETYPE_MAX_LEN) < 0) {
+ debug_error("error: Error in MIME Type finding\n");
return MMFILE_FORMAT_FAIL;
}
- memset (ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
+ memset(ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
- ret = mmfile_util_get_ffmpeg_format (mimeType,ffmpegFormatName);
+ ret = mmfile_util_get_ffmpeg_format(mimeType, ffmpegFormatName);
if (MMFILE_UTIL_SUCCESS != ret) {
- debug_error ("error: mmfile_util_get_ffmpeg_format\n");
+ debug_error("error: mmfile_util_get_ffmpeg_format\n");
return MMFILE_FORMAT_FAIL;
}
- grab_iformat = av_find_input_format (ffmpegFormatName);
+ grab_iformat = av_find_input_format(ffmpegFormatName);
if (NULL == grab_iformat) {
- debug_error ("error: cannot find format\n");
+ debug_error("error: cannot find format\n");
goto exception;
}
#ifdef __MMFILE_FFMPEG_V085__
- ret = avformat_open_input (&pFormatCtx, urifilename, grab_iformat, NULL);
+ ret = avformat_open_input(&pFormatCtx, urifilename, grab_iformat, NULL);
#else
- ret = av_open_input_file (&pFormatCtx, urifilename, grab_iformat, 0, NULL);
+ ret = av_open_input_file(&pFormatCtx, urifilename, grab_iformat, 0, NULL);
#endif
if (ret < 0) {
debug_error("error: cannot open %s %d\n", urifilename, ret);
}
if (!pFormatCtx) {
- debug_warning ("failed to find av stream. maybe corrupted data.\n");
+ debug_warning("failed to find av stream. maybe corrupted data.\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
if (pFormatCtx) avformat_close_input(&pFormatCtx);
return ret;
- }
+}
#define MIDI_MAX 255
#define VOL_INTERVAL 12
-
+
#define MIDI_HEADER_LENGTH 52
static unsigned char midiData[AV_MIDI_COUNT_MAX] ;
-static unsigned char midiHeader[MIDI_HEADER_LENGTH]= {0x4d,0x54,0x68,0x64,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x01,0x00,0x30,0x4d,0x54,
- 0x72,0x6b,0x00,0x00,0x00,0x00,0x00,0xff,0x58,0x04,0x04,0x02,0x18,0x08,0x00,0xff,
- 0x59,0x02,0x00,0x00,0x00,0xff,0x51,0x03,0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0xb0,
- 0x07,0x00,0x00,0x90};
+static unsigned char midiHeader[MIDI_HEADER_LENGTH] = {0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x30, 0x4d, 0x54,
+ 0x72, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x58, 0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xff,
+ 0x59, 0x02, 0x00, 0x00, 0x00, 0xff, 0x51, 0x03, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0xb0,
+ 0x07, 0x00, 0x00, 0x90
+ };
static unsigned char noteTotal[AV_MIDI_COUNT_MAX];
} noteData[AV_MIDI_NOTE_MAX];
/*imelody key string (to validatation check)*/
-static const char *g_imy_key_str [] = {
+static const char *g_imy_key_str[] = {
"BEGIN:IMELODY",
"VERSION:",
"FORMAT:",
};
-static int __is_good_imelody (unsigned char *src, unsigned int size);
-static unsigned char* __get_load_memory (char *src, int *out_size);
-static unsigned char __AvMIDISetVolume(char* pMelodyBuf);
-static int __AvMIDISetBeat(char* pMelodyBuf);
-static char __AvMIDISetStyle(char* pMelodyBuf);
-static unsigned char* __AvConvertIMelody2MIDI(char* pMelodyBuf, unsigned int* pBufLen);
-static int __get_imelody_tag (const char *uriname, tMMFileImelodyTagInfo *tags);
+static int __is_good_imelody(unsigned char *src, unsigned int size);
+static unsigned char *__get_load_memory(char *src, int *out_size);
+static unsigned char __AvMIDISetVolume(char *pMelodyBuf);
+static int __AvMIDISetBeat(char *pMelodyBuf);
+static char __AvMIDISetStyle(char *pMelodyBuf);
+static unsigned char *__AvConvertIMelody2MIDI(char *pMelodyBuf, unsigned int *pBufLen);
+static int __get_imelody_tag(const char *uriname, tMMFileImelodyTagInfo *tags);
+
-
/* interface functions */
-int mmfile_format_read_stream_imy (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_imy (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_imy (MMFileFormatContext *formatContext);
-int mmfile_format_close_imy (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_imy(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_imy(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_imy(MMFileFormatContext *formatContext);
+int mmfile_format_close_imy(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_imy (MMFileFormatContext *formatContext)
+int mmfile_format_open_imy(MMFileFormatContext *formatContext)
{
int ret = 0;
}
if (formatContext->pre_checked == 0) {
- ret = MMFileFormatIsValidIMY (NULL, formatContext->uriFileName);
+ ret = MMFileFormatIsValidIMY(NULL, formatContext->uriFileName);
if (ret == 0) {
debug_error("It is not imelody file\n");
return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_read_stream_imy (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_imy(MMFileFormatContext *formatContext)
{
MIDI_INFO_SIMPLE *info = NULL;
MMFileFormatStream *audioStream = NULL;
unsigned char *imy = NULL;
int imy_size = 0;
unsigned char *midi = NULL;
- unsigned int midi_size = 0;
- char src2[MMFILE_URI_MAX_LEN];
+ unsigned int midi_size = 0;
+ char src2[MMFILE_URI_MAX_LEN];
int ret = 0;
}
/*convert iMelody to Midi*/
- imy = __get_load_memory (formatContext->uriFileName, &imy_size);
+ imy = __get_load_memory(formatContext->uriFileName, &imy_size);
if (!imy) {
- debug_error ("failed to load memory.\n");
+ debug_error("failed to load memory.\n");
goto exception;
}
- ret = __is_good_imelody (imy, imy_size);
+ ret = __is_good_imelody(imy, imy_size);
if (ret != MMFILE_FORMAT_SUCCESS) {
- debug_error ("it's broken file.\n");
+ debug_error("it's broken file.\n");
goto exception;
}
- midi = __AvConvertIMelody2MIDI ((char *)imy, &midi_size);
+ midi = __AvConvertIMelody2MIDI((char *)imy, &midi_size);
if (!midi) {
- debug_error ("failed to convert.");
+ debug_error("failed to convert.");
goto exception;
}
/*make uri*/
- memset (src2, 0x00, MMFILE_URI_MAX_LEN);
- snprintf (src2, sizeof(src2), "%s%u:%u", MMFILE_MEM_URI, (unsigned int)midi, midi_size);
+ memset(src2, 0x00, MMFILE_URI_MAX_LEN);
+ snprintf(src2, sizeof(src2), "%s%u:%u", MMFILE_MEM_URI, (unsigned int)midi, midi_size);
/*get infomation*/
- info = mmfile_format_get_midi_infomation (src2);
+ info = mmfile_format_get_midi_infomation(src2);
if (!info) {
- debug_error ("failed to get infomation");
+ debug_error("failed to get infomation");
goto exception;
}
formatContext->nbStreams = 1;
- audioStream = mmfile_malloc (sizeof(MMFileFormatStream));
+ audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error ("error: mmfile_malloc audiostream\n");
+ debug_error("error: mmfile_malloc audiostream\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
audioStream->nbChannel = 1;
audioStream->samplePerSec = 0;
formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
-
- #ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
- #endif
-
- mmfile_free (imy);
- mmfile_free (midi);
- mmfile_format_free_midi_infomation (info);
+
+#ifdef __MMFILE_TEST_MODE__
+ mmfile_format_print_contents(formatContext);
+#endif
+
+ mmfile_free(imy);
+ mmfile_free(midi);
+ mmfile_format_free_midi_infomation(info);
return MMFILE_FORMAT_SUCCESS;
exception:
- mmfile_free (imy);
- mmfile_free (midi);
- mmfile_format_free_midi_infomation (info);
- mmfile_free (audioStream);
+ mmfile_free(imy);
+ mmfile_free(midi);
+ mmfile_format_free_midi_infomation(info);
+ mmfile_free(audioStream);
return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_read_frame_imy (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_imy(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_tag_imy (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_imy(MMFileFormatContext *formatContext)
{
- tMMFileImelodyTagInfo taginfo = {0,};
+ tMMFileImelodyTagInfo taginfo = {0, };
unsigned int tag_len;
unsigned int cnv_len;
- const char *locale = MMFileUtilGetLocale (NULL);
+ const char *locale = MMFileUtilGetLocale(NULL);
if (!formatContext) {
debug_error("formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
- __get_imelody_tag (formatContext->uriFileName, &taginfo);
+ __get_imelody_tag(formatContext->uriFileName, &taginfo);
/**
* UTF8 convert
*/
if (taginfo.title) {
- tag_len = strlen (taginfo.title);
+ tag_len = strlen(taginfo.title);
cnv_len = 0;
- formatContext->title = mmfile_string_convert ((const char*)taginfo.title,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
-
+ formatContext->title = mmfile_string_convert((const char *)taginfo.title,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
+
if (formatContext->title == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->title = mmfile_strdup (taginfo.title);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->title = mmfile_strdup(taginfo.title);
}
- mmfile_free (taginfo.title);
+ mmfile_free(taginfo.title);
}
if (taginfo.composer) {
- tag_len = strlen (taginfo.composer);
+ tag_len = strlen(taginfo.composer);
cnv_len = 0;
- formatContext->composer = mmfile_string_convert ((const char*)taginfo.composer,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
+ formatContext->composer = mmfile_string_convert((const char *)taginfo.composer,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
if (formatContext->composer == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->composer = mmfile_strdup (taginfo.composer);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->composer = mmfile_strdup(taginfo.composer);
}
- mmfile_free (taginfo.composer);
+ mmfile_free(taginfo.composer);
}
if (taginfo.comment) {
- tag_len = strlen (taginfo.comment);
+ tag_len = strlen(taginfo.comment);
cnv_len = 0;
- formatContext->comment = mmfile_string_convert ((const char*)taginfo.comment,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
+ formatContext->comment = mmfile_string_convert((const char *)taginfo.comment,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
if (formatContext->comment == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->comment = mmfile_strdup (taginfo.comment);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->comment = mmfile_strdup(taginfo.comment);
}
- mmfile_free (taginfo.comment);
+ mmfile_free(taginfo.comment);
}
if (taginfo.copyright) {
- tag_len = strlen (taginfo.copyright);
+ tag_len = strlen(taginfo.copyright);
cnv_len = 0;
- formatContext->copyright = mmfile_string_convert ((const char*)taginfo.copyright,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
+ formatContext->copyright = mmfile_string_convert((const char *)taginfo.copyright,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
if (formatContext->copyright == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->copyright = mmfile_strdup (taginfo.copyright);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->copyright = mmfile_strdup(taginfo.copyright);
}
- mmfile_free (taginfo.copyright);
+ mmfile_free(taginfo.copyright);
}
return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_close_imy (MMFileFormatContext *formatContext)
+int mmfile_format_close_imy(MMFileFormatContext *formatContext)
{
return MMFILE_FORMAT_SUCCESS;
}
-static int __get_imelody_tag (const char *uriname, tMMFileImelodyTagInfo *tags)
+static int __get_imelody_tag(const char *uriname, tMMFileImelodyTagInfo *tags)
{
#define _MMFILE_IMY_TAG_BUFFER_LENGTH 512
#define _MMFILE_IMY_HEADER_LENGTH 20
#define _MMFILE_IMY_KEY_BUFFER_LENGTH 20
#define _MMFILE_IMY_VALUE_BUFFER_LENGTH 128
- MMFileIOHandle *fp = NULL;
- unsigned char buffer[_MMFILE_IMY_TAG_BUFFER_LENGTH] = {0,};
- int readed = 0;
- long long filesize = 0;
- unsigned int startoffset = 0;
- unsigned int endoffset = 0;
- unsigned int i = 0, j = 0;
- char imy_key_buffer[_MMFILE_IMY_KEY_BUFFER_LENGTH] = {0,};
- unsigned int imy_key_buffer_index = 0;
- char imy_value_buffer[_MMFILE_IMY_VALUE_BUFFER_LENGTH] = {0,};
- unsigned int imy_value_buffer_index = 0;
- int isKeyBuffer = 1;
- int isDone = 0;
-
- int ret = MMFILE_FORMAT_FAIL;
-
- if (!uriname || !tags)
- {
- debug_error("uriname or tags is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- ret = mmfile_open (&fp, uriname, MMFILE_RDONLY);
- if (ret == MMFILE_UTIL_FAIL)
- {
- debug_error ( "open failed.\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- mmfile_seek (fp, 0, MMFILE_SEEK_END);
- filesize = mmfile_tell (fp);
- mmfile_seek (fp, 0, MMFILE_SEEK_SET);
-
- if (filesize < _MMFILE_IMY_HEADER_LENGTH)
- {
- debug_error ( "header is too small.\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exit;
- }
-
- /* set begin and end point at the file */
- startoffset = 0;
- endoffset = filesize;
-
- i = startoffset;
- isKeyBuffer = 1;
- while (i < endoffset)
- {
- mmfile_seek (fp, i, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_IMY_TAG_BUFFER_LENGTH);
- if (readed < 0)
- {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
- ret = 0;
- break;
- }
-
- j = 0;
- while (j < readed)
- {
- if ( *(buffer+j) == 0x3a )
- {
- isKeyBuffer = 0;
- }
- else if ( *(buffer+j) == 0x0d )
- {
- }
- else if ( *(buffer+j) == 0x0a )
- {
- isKeyBuffer = 1;
- isDone = 1;
- }
- else
- {
- if (isKeyBuffer)
- {
- if (imy_key_buffer_index < _MMFILE_IMY_KEY_BUFFER_LENGTH)
- {
- imy_key_buffer[imy_key_buffer_index++] = *(buffer+j);
- }
-
- }
- else
- {
- if (imy_value_buffer_index < _MMFILE_IMY_VALUE_BUFFER_LENGTH)
- {
- imy_value_buffer[imy_value_buffer_index++] = *(buffer+j);
- }
- }
- }
-
- if (isDone)
- {
- if (!strncmp (imy_key_buffer, "NAME", 4))
- {
- if(tags->title != NULL)
+ MMFileIOHandle *fp = NULL;
+ unsigned char buffer[_MMFILE_IMY_TAG_BUFFER_LENGTH] = {0, };
+ long long filesize = 0;
+ unsigned int startoffset = 0;
+ unsigned int endoffset = 0, i = 0;
+ int readed = 0, j = 0;
+ char imy_key_buffer[_MMFILE_IMY_KEY_BUFFER_LENGTH] = {0, };
+ unsigned int imy_key_buffer_index = 0;
+ char imy_value_buffer[_MMFILE_IMY_VALUE_BUFFER_LENGTH] = {0, };
+ unsigned int imy_value_buffer_index = 0;
+ int isKeyBuffer = 1;
+ int isDone = 0;
+
+ int ret = MMFILE_FORMAT_FAIL;
+
+ if (!uriname || !tags) {
+ debug_error("uriname or tags is NULL\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ ret = mmfile_open(&fp, uriname, MMFILE_RDONLY);
+ if (ret == MMFILE_UTIL_FAIL) {
+ debug_error("open failed.\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ mmfile_seek(fp, 0, MMFILE_SEEK_END);
+ filesize = mmfile_tell(fp);
+ mmfile_seek(fp, 0, MMFILE_SEEK_SET);
+
+ if (filesize < _MMFILE_IMY_HEADER_LENGTH) {
+ debug_error("header is too small.\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exit;
+ }
+
+ /* set begin and end point at the file */
+ startoffset = 0;
+ endoffset = filesize;
+
+ i = startoffset;
+ isKeyBuffer = 1;
+ while (i < endoffset) {
+ mmfile_seek(fp, i, MMFILE_SEEK_SET);
+ readed = mmfile_read(fp, buffer, _MMFILE_IMY_TAG_BUFFER_LENGTH);
+ if (readed < 0) {
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
+ ret = 0;
+ break;
+ }
+
+ j = 0;
+ while (j < readed) {
+ if (*(buffer + j) == 0x3a) {
+ isKeyBuffer = 0;
+ } else if (*(buffer + j) == 0x0d) {
+ } else if (*(buffer + j) == 0x0a) {
+ isKeyBuffer = 1;
+ isDone = 1;
+ } else {
+ if (isKeyBuffer) {
+ if (imy_key_buffer_index < _MMFILE_IMY_KEY_BUFFER_LENGTH) {
+ imy_key_buffer[imy_key_buffer_index++] = *(buffer + j);
+ }
+
+ } else {
+ if (imy_value_buffer_index < _MMFILE_IMY_VALUE_BUFFER_LENGTH) {
+ imy_value_buffer[imy_value_buffer_index++] = *(buffer + j);
+ }
+ }
+ }
+
+ if (isDone) {
+ if (!strncmp(imy_key_buffer, "NAME", 4)) {
+ if (tags->title != NULL)
mmfile_free(tags->title);
- tags->title = mmfile_strdup (imy_value_buffer);
- }
- else if (!strncmp (imy_key_buffer, "COMPOSER", 8))
- {
- if(tags->composer != NULL)
+ tags->title = mmfile_strdup(imy_value_buffer);
+ } else if (!strncmp(imy_key_buffer, "COMPOSER", 8)) {
+ if (tags->composer != NULL)
mmfile_free(tags->composer);
- tags->composer = mmfile_strdup (imy_value_buffer);
- }
- else if (!strncmp (imy_key_buffer, "COPYRIGHT", 9))
- {
- if(tags->copyright != NULL)
+ tags->composer = mmfile_strdup(imy_value_buffer);
+ } else if (!strncmp(imy_key_buffer, "COPYRIGHT", 9)) {
+ if (tags->copyright != NULL)
mmfile_free(tags->copyright);
- tags->copyright = mmfile_strdup (imy_value_buffer);
- }
+ tags->copyright = mmfile_strdup(imy_value_buffer);
+ }
- memset (imy_key_buffer, 0x00, _MMFILE_IMY_KEY_BUFFER_LENGTH);
- memset (imy_value_buffer, 0x00, _MMFILE_IMY_VALUE_BUFFER_LENGTH);
- imy_key_buffer_index = 0;
- imy_value_buffer_index = 0;
- isDone = 0;
- }
+ memset(imy_key_buffer, 0x00, _MMFILE_IMY_KEY_BUFFER_LENGTH);
+ memset(imy_value_buffer, 0x00, _MMFILE_IMY_VALUE_BUFFER_LENGTH);
+ imy_key_buffer_index = 0;
+ imy_value_buffer_index = 0;
+ isDone = 0;
+ }
- j++;
- }
+ j++;
+ }
- memset (buffer, 0x00, _MMFILE_IMY_TAG_BUFFER_LENGTH);
+ memset(buffer, 0x00, _MMFILE_IMY_TAG_BUFFER_LENGTH);
- i = i + j;
- }
+ i = i + j;
+ }
exit:
- mmfile_close (fp);
- return ret;
+ mmfile_close(fp);
+ return ret;
}
static unsigned char *
-__get_load_memory (char *src, int *out_size)
+__get_load_memory(char *src, int *out_size)
{
unsigned char *buf = NULL;
MMFileIOHandle *fp = NULL;
long long src_size = 0L;
- int readed =0;
+ int readed = 0;
int ret = 0;
/*open*/
- ret = mmfile_open (&fp, src, MMFILE_RDONLY);
+ ret = mmfile_open(&fp, src, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error ( "open failed.\n");
+ debug_error("open failed.\n");
return NULL;
}
/*get file size*/
- mmfile_seek (fp, 0L, MMFILE_SEEK_END);
- src_size = mmfile_tell (fp);
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_END);
+ src_size = mmfile_tell(fp);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (src_size <= 0) {
- debug_error ("failed to get file size.\n");
+ debug_error("failed to get file size.\n");
goto failed;
}
/*alloc read buffer*/
- if ((buf = mmfile_malloc (src_size)) == NULL) {
- debug_error ( "memory allocation failed.\n");
+ if ((buf = mmfile_malloc(src_size)) == NULL) {
+ debug_error("memory allocation failed.\n");
goto failed;
}
/*read data*/
- if ((readed = mmfile_read (fp, buf, src_size) ) != src_size) {
- debug_error ( "read error. size = %d\n", readed);
+ if ((readed = mmfile_read(fp, buf, src_size)) != src_size) {
+ debug_error("read error. size = %d\n", readed);
goto failed;
}
*out_size = (int)src_size;
- mmfile_close (fp);
+ mmfile_close(fp);
return buf;
-
+
failed:
- if (buf) mmfile_free (buf);
- if (fp) mmfile_close (fp);
+ if (buf) mmfile_free(buf);
+ if (fp) mmfile_close(fp);
return NULL;
}
static int
-__is_good_imelody (unsigned char *src, unsigned int size)
+__is_good_imelody(unsigned char *src, unsigned int size)
{
- int i, j;
+ unsigned int i, j;
int key_len;
int is_found;
unsigned char *p;
- int num = sizeof (g_imy_key_str) / sizeof (g_imy_key_str[0]);
+ unsigned int num = sizeof(g_imy_key_str) / sizeof(g_imy_key_str[0]);
for (i = 0; i < num; i++) {
- key_len = strlen (g_imy_key_str[i]);
+ key_len = strlen(g_imy_key_str[i]);
p = src;
is_found = 0;
for (j = 0; j <= size - key_len; j++, p++) {
- if (memcmp (g_imy_key_str[i], p, key_len) == 0) {
+ if (memcmp(g_imy_key_str[i], p, key_len) == 0) {
is_found = 1;
break;
}
}
- if (is_found) continue; else return MMFILE_FORMAT_FAIL;
+ if (is_found) continue;
+ else return MMFILE_FORMAT_FAIL;
}
return MMFILE_FORMAT_SUCCESS;
}
-static unsigned char*
-__AvConvertIMelody2MIDI(char* pMelodyBuf, unsigned int* pBufLen)
+static unsigned char *
+__AvConvertIMelody2MIDI(char *pMelodyBuf, unsigned int *pBufLen)
{
- unsigned char* pConvertBuf;
- char* pStart;
- char* pMelodyStart;
+ unsigned char *pConvertBuf;
+ char *pStart;
+ char *pMelodyStart;
char noteBase[6];
int octaveCount;
int octaveValue;
char vol = '%';
int volInterval = 0;
- for(count = 0;count < AV_MIDI_NOTE_MAX;count++)
- {
+ for (count = 0; count < AV_MIDI_NOTE_MAX; count++) {
restSpec[count] = 0;
durationSpec[count] = 0;
}
- for(octaveCount = 0;octaveCount < AV_MIDI_NOTE_MAX;octaveCount++)
+ for (octaveCount = 0; octaveCount < AV_MIDI_NOTE_MAX; octaveCount++)
octave[octaveCount] = '%';
- for(MelodyCount = 0;MelodyCount < AV_MIDI_NOTE_MAX;MelodyCount++)
- {
+ for (MelodyCount = 0; MelodyCount < AV_MIDI_NOTE_MAX; MelodyCount++) {
Melody[MelodyCount].flat_sharp = '%';
Melody[MelodyCount].note = '%';
Melody[MelodyCount].duration = '%';
Melody[MelodyCount].vol = '%';
}
- for(MelodyCount = 0;MelodyCount < AV_MIDI_NOTE_MAX;MelodyCount++)
- {
+ for (MelodyCount = 0; MelodyCount < AV_MIDI_NOTE_MAX; MelodyCount++) {
noteData[MelodyCount].note = 0;
noteData[MelodyCount].duration_on = 0;
noteData[MelodyCount].duration_off = 0;
tempoValue = __AvMIDISetBeat(pMelodyBuf);
- for(number = 0;tempoValue != 0;number++)
- {
+ for (number = 0; tempoValue != 0; number++) {
tempoData[0] = tempoValue % 16;
tempoValue = tempoValue / 16;
tempoData[2] = tempoData[0] + tempoData[1] * 16;
- midiData[42-number] = tempoData[2];
+ midiData[42 - number] = tempoData[2];
}
pMelodyBuf = pStart;
- while(!(*pMelodyBuf == '@' || (*pMelodyBuf == 'E' && *(pMelodyBuf+2) == 'D')))
+ while (!(*pMelodyBuf == '@' || (*pMelodyBuf == 'E' && *(pMelodyBuf + 2) == 'D')))
pMelodyBuf++;
pMelodyBuf++;
- if(*pMelodyBuf >= '1' && *pMelodyBuf <= '9')
- {
+ if (*pMelodyBuf >= '1' && *pMelodyBuf <= '9') {
repeat = *pMelodyBuf - '0';
pMelodyBuf++;
pMelodyBuf = pMelodyBuf + 42;
- while(!(*pMelodyBuf == 'M' && *(pMelodyBuf+5) == 'Y' && *(pMelodyBuf+6) == ':')) //2007-02-28 AVMS_Sound:k2bogus - UMTS200073205;imy play, [MELODY:] extract fix
+ while (!(*pMelodyBuf == 'M' && *(pMelodyBuf + 5) == 'Y' && *(pMelodyBuf + 6) == ':')) /*2007-02-28 AVMS_Sound:k2bogus - UMTS200073205;imy play, [MELODY:] extract fix */
pMelodyBuf++;
pMelodyBuf = pMelodyBuf + 6;
* why? mobileBAE player stopped at newline.
* 2009/08/12
*/
- while(!((*pMelodyBuf == 'E' && *(pMelodyBuf+2) == 'D') || (*pMelodyBuf == '\n')))
- {
- if(noteCount>=AV_MIDI_NOTE_MAX)
- {
- debug_warning ("__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
+ while (!((*pMelodyBuf == 'E' && *(pMelodyBuf + 2) == 'D') || (*pMelodyBuf == '\n'))) {
+ if (noteCount >= AV_MIDI_NOTE_MAX) {
+ debug_warning("__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
break;
}
-
+
pMelodyBuf++;
-
- if(*pMelodyBuf == '*')
- {
+
+ if (*pMelodyBuf == '*') {
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '8')
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '8')
octave[noteCount] = *pMelodyBuf;
}
- if(*pMelodyBuf == '#' || *pMelodyBuf == '&')
+ if (*pMelodyBuf == '#' || *pMelodyBuf == '&')
Melody[noteCount].flat_sharp = *pMelodyBuf;
- if(*pMelodyBuf == 'r')
- {
+ if (*pMelodyBuf == 'r') {
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '5')
- {
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '5') {
Melody[noteCount].rest = *pMelodyBuf;
pMelodyBuf++;
- if(*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
+ if (*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
Melody[noteCount].rest_specifier = *pMelodyBuf;
}
}
-
- if(*pMelodyBuf == 'V')
- {
+
+ if (*pMelodyBuf == 'V') {
pMelodyBuf++;
- if(*pMelodyBuf == '+' || *pMelodyBuf == '-')
+ if (*pMelodyBuf == '+' || *pMelodyBuf == '-')
Melody[noteCount].vol = *pMelodyBuf;
}
- if(*pMelodyBuf >= 'a' && *pMelodyBuf <= 'g')
- {
+ if (*pMelodyBuf >= 'a' && *pMelodyBuf <= 'g') {
Melody[noteCount].note = *pMelodyBuf;
pMelodyBuf++;
-
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '5')
- {
+
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '5') {
Melody[noteCount].duration = *pMelodyBuf;
pMelodyBuf++;
- if(*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
+ if (*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
Melody[noteCount].duration_specifier = *pMelodyBuf;
else
}
}
- for(octaveCount = 1;octaveCount < noteCount;octaveCount++)
- {
- if(octave[octaveCount] == '%')
- octave[octaveCount] = octave[octaveCount-1];
+ for (octaveCount = 1; octaveCount < noteCount; octaveCount++) {
+ if (octave[octaveCount] == '%')
+ octave[octaveCount] = octave[octaveCount - 1];
}
- for(number = 0;number < noteCount;number++)
- {
- if(octave[0] == '%' && octave[number] == '%')
+ for (number = 0; number < noteCount; number++) {
+ if (octave[0] == '%' && octave[number] == '%')
octaveValue = 4;
-
+
else
octaveValue = octave[number] - '0';
octaveValue = octaveValue * 12;
- if(Melody[number].flat_sharp == '#')
- {
- switch(Melody[number].note)
- {
- case 'c': noteData[number].note = octaveValue + 1;
- break;
- case 'd': noteData[number].note = octaveValue + 3;
- break;
- case 'f': noteData[number].note = octaveValue + 6;
- break;
- case 'g': noteData[number].note = octaveValue + 8;
- break;
- case 'a': noteData[number].note = octaveValue + 10;
- break;
- default :
- break;
+ if (Melody[number].flat_sharp == '#') {
+ switch (Melody[number].note) {
+ case 'c':
+ noteData[number].note = octaveValue + 1;
+ break;
+ case 'd':
+ noteData[number].note = octaveValue + 3;
+ break;
+ case 'f':
+ noteData[number].note = octaveValue + 6;
+ break;
+ case 'g':
+ noteData[number].note = octaveValue + 8;
+ break;
+ case 'a':
+ noteData[number].note = octaveValue + 10;
+ break;
+ default:
+ break;
}
}
- else
- if(Melody[number].flat_sharp == '&')
- {
- switch(Melody[number].note)
- {
- case 'd': noteData[number].note = octaveValue + 1;
- break;
- case 'e': noteData[number].note = octaveValue + 3;
- break;
- case 'g': noteData[number].note = octaveValue + 6;
- break;
- case 'a': noteData[number].note = octaveValue + 8;
- break;
- case 'b': noteData[number].note = octaveValue + 10;
- break;
- default :
- break;
+ else if (Melody[number].flat_sharp == '&') {
+ switch (Melody[number].note) {
+ case 'd':
+ noteData[number].note = octaveValue + 1;
+ break;
+ case 'e':
+ noteData[number].note = octaveValue + 3;
+ break;
+ case 'g':
+ noteData[number].note = octaveValue + 6;
+ break;
+ case 'a':
+ noteData[number].note = octaveValue + 8;
+ break;
+ case 'b':
+ noteData[number].note = octaveValue + 10;
+ break;
+ default:
+ break;
}
}
- else
- {
- switch(Melody[number].note)
- {
- case 'c': noteData[number].note = octaveValue;
- break;
- case 'd': noteData[number].note = octaveValue + 2;
- break;
- case 'e': noteData[number].note = octaveValue + 4;
- break;
- case 'f': noteData[number].note = octaveValue + 5;
- break;
- case 'g': noteData[number].note = octaveValue + 7;
- break;
- case 'a': noteData[number].note = octaveValue + 9;
- break;
- case 'b': noteData[number].note = octaveValue + 11;
- break;
- default :
- break;
+ else {
+ switch (Melody[number].note) {
+ case 'c':
+ noteData[number].note = octaveValue;
+ break;
+ case 'd':
+ noteData[number].note = octaveValue + 2;
+ break;
+ case 'e':
+ noteData[number].note = octaveValue + 4;
+ break;
+ case 'f':
+ noteData[number].note = octaveValue + 5;
+ break;
+ case 'g':
+ noteData[number].note = octaveValue + 7;
+ break;
+ case 'a':
+ noteData[number].note = octaveValue + 9;
+ break;
+ case 'b':
+ noteData[number].note = octaveValue + 11;
+ break;
+ default:
+ break;
}
}
}
style = __AvMIDISetStyle(pMelodyBuf);
- for(number = 0;number < noteCount;number++)
- {
- if(style == '0')
- {
- switch(Melody[number].duration)
- {
- case '0': noteData[number].duration_on = 183;
- noteData[number].duration_off = 9;
- break;
- case '1': noteData[number].duration_on = 91;
- noteData[number].duration_off = 5;
- break;
- case '2': noteData[number].duration_on = 46;
- noteData[number].duration_off = 2;
- break;
- case '3': noteData[number].duration_on = 23;
- noteData[number].duration_off = 1;
- break;
- case '4': noteData[number].duration_on = 11;
- noteData[number].duration_off = 1;
- break;
- case '5': noteData[number].duration_on = 5;
- noteData[number].duration_off = 1;
- break;
- default :
- break;
+ for (number = 0; number < noteCount; number++) {
+ if (style == '0') {
+ switch (Melody[number].duration) {
+ case '0':
+ noteData[number].duration_on = 183;
+ noteData[number].duration_off = 9;
+ break;
+ case '1':
+ noteData[number].duration_on = 91;
+ noteData[number].duration_off = 5;
+ break;
+ case '2':
+ noteData[number].duration_on = 46;
+ noteData[number].duration_off = 2;
+ break;
+ case '3':
+ noteData[number].duration_on = 23;
+ noteData[number].duration_off = 1;
+ break;
+ case '4':
+ noteData[number].duration_on = 11;
+ noteData[number].duration_off = 1;
+ break;
+ case '5':
+ noteData[number].duration_on = 5;
+ noteData[number].duration_off = 1;
+ break;
+ default:
+ break;
}
}
- else
- if(style == '1')
- {
- switch(Melody[number].duration)
- {
- case '0': noteData[number].duration_on = 192;
- noteData[number].duration_off = 0;
- break;
- case '1': noteData[number].duration_on = 96;
- noteData[number].duration_off = 0;
- break;
- case '2': noteData[number].duration_on = 48;
- noteData[number].duration_off = 0;
- break;
- case '3': noteData[number].duration_on = 24;
- noteData[number].duration_off = 0;
- break;
- case '4': noteData[number].duration_on = 12;
- noteData[number].duration_off = 0;
- break;
- case '5': noteData[number].duration_on = 6;
- noteData[number].duration_off = 0;
- break;
- default :
- break;
+ else if (style == '1') {
+ switch (Melody[number].duration) {
+ case '0':
+ noteData[number].duration_on = 192;
+ noteData[number].duration_off = 0;
+ break;
+ case '1':
+ noteData[number].duration_on = 96;
+ noteData[number].duration_off = 0;
+ break;
+ case '2':
+ noteData[number].duration_on = 48;
+ noteData[number].duration_off = 0;
+ break;
+ case '3':
+ noteData[number].duration_on = 24;
+ noteData[number].duration_off = 0;
+ break;
+ case '4':
+ noteData[number].duration_on = 12;
+ noteData[number].duration_off = 0;
+ break;
+ case '5':
+ noteData[number].duration_on = 6;
+ noteData[number].duration_off = 0;
+ break;
+ default:
+ break;
}
}
- else
- {
- switch(Melody[number].duration)
- {
- case '0': noteData[number].duration_on = 96;
- noteData[number].duration_off = 96;
- break;
- case '1': noteData[number].duration_on = 48;
- noteData[number].duration_off = 48;
- break;
- case '2': noteData[number].duration_on = 24;
- noteData[number].duration_off = 24;
- break;
- case '3': noteData[number].duration_on = 12;
- noteData[number].duration_off = 12;
- break;
- case '4': noteData[number].duration_on = 6;
- noteData[number].duration_off = 6;
- break;
- case '5': noteData[number].duration_on = 3;
- noteData[number].duration_off = 3;
- break;
- default :
- break;
+ else {
+ switch (Melody[number].duration) {
+ case '0':
+ noteData[number].duration_on = 96;
+ noteData[number].duration_off = 96;
+ break;
+ case '1':
+ noteData[number].duration_on = 48;
+ noteData[number].duration_off = 48;
+ break;
+ case '2':
+ noteData[number].duration_on = 24;
+ noteData[number].duration_off = 24;
+ break;
+ case '3':
+ noteData[number].duration_on = 12;
+ noteData[number].duration_off = 12;
+ break;
+ case '4':
+ noteData[number].duration_on = 6;
+ noteData[number].duration_off = 6;
+ break;
+ case '5':
+ noteData[number].duration_on = 3;
+ noteData[number].duration_off = 3;
+ break;
+ default:
+ break;
}
}
- switch(Melody[number].duration)
- {
- case '0': durationSpec[number] = 192;
- break;
- case '1': durationSpec[number] = 96;
- break;
- case '2': durationSpec[number] = 48;
- break;
- case '3': durationSpec[number] = 24;
- break;
- case '4': durationSpec[number] = 12;
- break;
- case '5': durationSpec[number] = 6;
- break;
- default :
- break;
+ switch (Melody[number].duration) {
+ case '0':
+ durationSpec[number] = 192;
+ break;
+ case '1':
+ durationSpec[number] = 96;
+ break;
+ case '2':
+ durationSpec[number] = 48;
+ break;
+ case '3':
+ durationSpec[number] = 24;
+ break;
+ case '4':
+ durationSpec[number] = 12;
+ break;
+ case '5':
+ durationSpec[number] = 6;
+ break;
+ default:
+ break;
}
- if(Melody[number].duration_specifier != '%')
- {
- switch(Melody[number].duration_specifier)
- {
- case '.': noteData[number].duration_on += (durationSpec[number] / 2);
- break;
- case ':': noteData[number].duration_on += durationSpec[number];
- break;
- case ';': noteData[number].duration_on -= (durationSpec[number] / 3);
- break;
- default :
- break;
+ if (Melody[number].duration_specifier != '%') {
+ switch (Melody[number].duration_specifier) {
+ case '.':
+ noteData[number].duration_on += (durationSpec[number] / 2);
+ break;
+ case ':':
+ noteData[number].duration_on += durationSpec[number];
+ break;
+ case ';':
+ noteData[number].duration_on -= (durationSpec[number] / 3);
+ break;
+ default:
+ break;
}
- if(noteData[number].duration_on > MIDI_MAX)
+ if (noteData[number].duration_on > MIDI_MAX)
noteData[number].duration_on = MIDI_LIMIT;
}
}
- for(number = 1;number < noteCount;number++)
- {
- if(Melody[number].rest >= '0' && Melody[number].rest <= '5')
- {
- switch(Melody[number].rest)
- {
- case '0': noteData[number-1].duration_off += 192;
- restSpec[number] = 192;
- break;
- case '1': noteData[number-1].duration_off += 96;
- restSpec[number] = 96;
- break;
- case '2': noteData[number-1].duration_off += 48;
- restSpec[number] = 48;
- break;
- case '3': noteData[number-1].duration_off += 24;
- restSpec[number] = 24;
- break;
- case '4': noteData[number-1].duration_off += 12;
- restSpec[number] = 12;
- break;
- case '5': noteData[number-1].duration_off += 6;
- restSpec[number] = 6;
- break;
- default :
- break;
+ for (number = 1; number < noteCount; number++) {
+ if (Melody[number].rest >= '0' && Melody[number].rest <= '5') {
+ switch (Melody[number].rest) {
+ case '0':
+ noteData[number - 1].duration_off += 192;
+ restSpec[number] = 192;
+ break;
+ case '1':
+ noteData[number - 1].duration_off += 96;
+ restSpec[number] = 96;
+ break;
+ case '2':
+ noteData[number - 1].duration_off += 48;
+ restSpec[number] = 48;
+ break;
+ case '3':
+ noteData[number - 1].duration_off += 24;
+ restSpec[number] = 24;
+ break;
+ case '4':
+ noteData[number - 1].duration_off += 12;
+ restSpec[number] = 12;
+ break;
+ case '5':
+ noteData[number - 1].duration_off += 6;
+ restSpec[number] = 6;
+ break;
+ default:
+ break;
}
- if(noteData[number-1].duration_off > MIDI_MAX && Melody[number].rest_specifier == '%')
- noteData[number-1].duration_off = MIDI_LIMIT;
+ if (noteData[number - 1].duration_off > MIDI_MAX && Melody[number].rest_specifier == '%')
+ noteData[number - 1].duration_off = MIDI_LIMIT;
}
- if(Melody[number].rest_specifier != '%')
- {
- switch(Melody[number].rest_specifier)
- {
- case '.': noteData[number-1].duration_off += (restSpec[number] / 2);
- break;
- case ':': noteData[number-1].duration_off += restSpec[number];
- break;
- case ';': noteData[number-1].duration_off -= (restSpec[number] / 3);
- break;
- default :
- break;
+ if (Melody[number].rest_specifier != '%') {
+ switch (Melody[number].rest_specifier) {
+ case '.':
+ noteData[number - 1].duration_off += (restSpec[number] / 2);
+ break;
+ case ':':
+ noteData[number - 1].duration_off += restSpec[number];
+ break;
+ case ';':
+ noteData[number - 1].duration_off -= (restSpec[number] / 3);
+ break;
+ default:
+ break;
}
- if(noteData[number-1].duration_off > MIDI_MAX)
- noteData[number-1].duration_off = MIDI_LIMIT;
+ if (noteData[number - 1].duration_off > MIDI_MAX)
+ noteData[number - 1].duration_off = MIDI_LIMIT;
}
}
- if(Melody[0].rest >= '0' && Melody[0].rest <= '5')
- {
- switch(Melody[0].rest)
- {
- case '0': midiData[50] += 192;
- restSpec[0] = 192;
- break;
- case '1': midiData[50] += 96;
- restSpec[0] = 96;
- break;
- case '2': midiData[50] += 48;
- restSpec[0] = 48;
- break;
- case '3': midiData[50] += 24;
- restSpec[0] = 24;
- break;
- case '4': midiData[50] += 12;
- restSpec[0] = 12;
- break;
- case '5': midiData[50] += 6;
- restSpec[0] = 6;
- break;
- default :
- break;
+ if (Melody[0].rest >= '0' && Melody[0].rest <= '5') {
+ switch (Melody[0].rest) {
+ case '0':
+ midiData[50] += 192;
+ restSpec[0] = 192;
+ break;
+ case '1':
+ midiData[50] += 96;
+ restSpec[0] = 96;
+ break;
+ case '2':
+ midiData[50] += 48;
+ restSpec[0] = 48;
+ break;
+ case '3':
+ midiData[50] += 24;
+ restSpec[0] = 24;
+ break;
+ case '4':
+ midiData[50] += 12;
+ restSpec[0] = 12;
+ break;
+ case '5':
+ midiData[50] += 6;
+ restSpec[0] = 6;
+ break;
+ default:
+ break;
}
- if(Melody[0].rest_specifier != '%')
- {
- switch(Melody[0].rest_specifier)
- {
- case '.': midiData[50] += (restSpec[0] / 2);
- break;
- case ':': midiData[50] += restSpec[0];
- break;
- case ';': midiData[50] -= (restSpec[0] / 3);
- break;
- default :
- break;
+ if (Melody[0].rest_specifier != '%') {
+ switch (Melody[0].rest_specifier) {
+ case '.':
+ midiData[50] += (restSpec[0] / 2);
+ break;
+ case ':':
+ midiData[50] += restSpec[0];
+ break;
+ case ';':
+ midiData[50] -= (restSpec[0] / 3);
+ break;
+ default:
+ break;
}
}
- if(midiData[50] > MIDI_LIMIT)
+ if (midiData[50] > MIDI_LIMIT)
midiData[50] = MIDI_LIMIT;
- if(Melody[0].rest == '0')
+ if (Melody[0].rest == '0')
midiData[50] = MIDI_LIMIT;
}
- for(number = 0;number < noteCount;number++)
- {
+ for (number = 0; number < noteCount; number++) {
noteBase[0] = noteData[number].note;
noteBase[2] = noteData[number].duration_on;
noteBase[3] = noteData[number].note;
noteBase[5] = noteData[number].duration_off;
- noteTotal[6*number] = noteBase[0];
- noteTotal[6*number+2] = noteBase[2];
- noteTotal[6*number+3] = noteBase[3];
- noteTotal[6*number+5] = noteBase[5];
- noteTotal[6*number+4] = 0;
+ noteTotal[6 * number] = noteBase[0];
+ noteTotal[6 * number + 2] = noteBase[2];
+ noteTotal[6 * number + 3] = noteBase[3];
+ noteTotal[6 * number + 5] = noteBase[5];
+ noteTotal[6 * number + 4] = 0;
- if(noteTotal[6*number+2] > MIDI_LIMIT)
- noteTotal[6*number+2] = MIDI_LIMIT;
+ if (noteTotal[6 * number + 2] > MIDI_LIMIT)
+ noteTotal[6 * number + 2] = MIDI_LIMIT;
- if(noteTotal[6*number+5] > MIDI_LIMIT)
- noteTotal[6*number+5] = MIDI_LIMIT;
+ if (noteTotal[6 * number + 5] > MIDI_LIMIT)
+ noteTotal[6 * number + 5] = MIDI_LIMIT;
}
- for(number = 1;number < noteCount;number++)
- {
+ for (number = 1; number < noteCount; number++) {
noteTotal[1] = 84;
- if(Melody[0].vol == '+')
+ if (Melody[0].vol == '+')
noteTotal[1] = 84 + VOL_INTERVAL;
- if(Melody[0].vol == '-')
+ if (Melody[0].vol == '-')
noteTotal[1] = 84 - VOL_INTERVAL;
- switch(Melody[number].vol)
- {
- case '+': noteTotal[6*number+1] = noteTotal[6*(number-1)+1] + VOL_INTERVAL;
- break;
- case '-': noteTotal[6*number+1] = noteTotal[6*(number-1)+1] - VOL_INTERVAL;
- break;
- default :
- break;
+ switch (Melody[number].vol) {
+ case '+':
+ noteTotal[6 * number + 1] = noteTotal[6 * (number - 1) + 1] + VOL_INTERVAL;
+ break;
+ case '-':
+ noteTotal[6 * number + 1] = noteTotal[6 * (number - 1) + 1] - VOL_INTERVAL;
+ break;
+ default:
+ break;
}
- if(noteTotal[6*number+1] > MIDI_LIMIT)
- noteTotal[6*number+1] = MIDI_LIMIT;
+ if (noteTotal[6 * number + 1] > MIDI_LIMIT)
+ noteTotal[6 * number + 1] = MIDI_LIMIT;
- if((noteTotal[6*(number-1)+1] == 0 || noteTotal[6*(number-1)+1] == 7) && Melody[number].vol == '-')
- noteTotal[6*number+1] = 0;
+ if ((noteTotal[6 * (number - 1) + 1] == 0 || noteTotal[6 * (number - 1) + 1] == 7) && Melody[number].vol == '-')
+ noteTotal[6 * number + 1] = 0;
- if(Melody[number].vol == '%')
- noteTotal[6*number+1] = noteTotal[6*(number-1)+1];
+ if (Melody[number].vol == '%')
+ noteTotal[6 * number + 1] = noteTotal[6 * (number - 1) + 1];
}
- for(number = 0;number < 6 * noteCount;number++)
- midiData[52+number] = noteTotal[number];
+ for (number = 0; number < 6 * noteCount; number++)
+ midiData[52 + number] = noteTotal[number];
- for(number = 6 * noteCount;number < 6 * noteCount * (repeat + 1);number++)
- {
+ for (number = 6 * noteCount; number < 6 * noteCount * (repeat + 1); number++) {
noteTotal[number] = noteTotal[repeatCount];
- midiData[52+number] = noteTotal[number];
+ midiData[52 + number] = noteTotal[number];
repeatCount++;
- if(repeatCount == 6 * noteCount)
+ if (repeatCount == 6 * noteCount)
repeatCount = 0;
}
- if(vol != '%')
- {
- switch(vol)
- {
- case '+': midiData[52+(6*noteCount+1)] = midiData[52+(6*(noteCount-1)+1)] + VOL_INTERVAL;
- break;
- case '-': midiData[52+(6*noteCount+1)] = midiData[52+(6*(noteCount-1)+1)] - VOL_INTERVAL;
- break;
- default :
- break;
+ if (vol != '%') {
+ switch (vol) {
+ case '+':
+ midiData[52 + (6 * noteCount + 1)] = midiData[52 + (6 * (noteCount - 1) + 1)] + VOL_INTERVAL;
+ break;
+ case '-':
+ midiData[52 + (6 * noteCount + 1)] = midiData[52 + (6 * (noteCount - 1) + 1)] - VOL_INTERVAL;
+ break;
+ default:
+ break;
}
- if(Melody[0].vol != '%')
- {
- switch(Melody[0].vol)
- {
- case '+': midiData[52+(6*noteCount+1)] += VOL_INTERVAL;
- break;
- case '-': midiData[52+(6*noteCount+1)] -= VOL_INTERVAL;
- break;
- default :
- break;
+ if (Melody[0].vol != '%') {
+ switch (Melody[0].vol) {
+ case '+':
+ midiData[52 + (6 * noteCount + 1)] += VOL_INTERVAL;
+ break;
+ case '-':
+ midiData[52 + (6 * noteCount + 1)] -= VOL_INTERVAL;
+ break;
+ default:
+ break;
}
}
- if(midiData[52+(6*noteCount+1)] > MIDI_LIMIT)
- midiData[52+(6*noteCount+1)] = MIDI_LIMIT;
+ if (midiData[52 + (6 * noteCount + 1)] > MIDI_LIMIT)
+ midiData[52 + (6 * noteCount + 1)] = MIDI_LIMIT;
- if((midiData[52+(6*(noteCount-1)+1)] == 0 || midiData[52+(6*(noteCount-1)+1)] == 7) && vol == '-')
- {
- midiData[52+(6*noteCount+1)] = 0;
+ if ((midiData[52 + (6 * (noteCount - 1) + 1)] == 0 || midiData[52 + (6 * (noteCount - 1) + 1)] == 7) && vol == '-') {
+ midiData[52 + (6 * noteCount + 1)] = 0;
- if(Melody[0].vol == '+')
- midiData[52+(6*noteCount+1)] = 12;
+ if (Melody[0].vol == '+')
+ midiData[52 + (6 * noteCount + 1)] = 12;
}
- if((midiData[52+(6*(noteCount-1)+1)] == 12 || midiData[52+(6*(noteCount-1)+1)] == 19) && vol == '-' && Melody[0].vol == '-')
- midiData[52+(6*noteCount+1)] = 0;
+ if ((midiData[52 + (6 * (noteCount - 1) + 1)] == 12 || midiData[52 + (6 * (noteCount - 1) + 1)] == 19) && vol == '-' && Melody[0].vol == '-')
+ midiData[52 + (6 * noteCount + 1)] = 0;
}
- else
- if(Melody[0].vol != '%' && vol == '%' && repeat != 0)
- {
- switch(Melody[0].vol)
- {
- case '+': midiData[52+(6*noteCount+1)] = midiData[52+(6*(noteCount-1)+1)] + VOL_INTERVAL;
- break;
- case '-': midiData[52+(6*noteCount+1)] = midiData[52+(6*(noteCount-1)+1)] - VOL_INTERVAL;
- break;
- default :
- break;
+ else if (Melody[0].vol != '%' && vol == '%' && repeat != 0) {
+ switch (Melody[0].vol) {
+ case '+':
+ midiData[52 + (6 * noteCount + 1)] = midiData[52 + (6 * (noteCount - 1) + 1)] + VOL_INTERVAL;
+ break;
+ case '-':
+ midiData[52 + (6 * noteCount + 1)] = midiData[52 + (6 * (noteCount - 1) + 1)] - VOL_INTERVAL;
+ break;
+ default:
+ break;
}
- if(midiData[52+(6*noteCount+1)] > MIDI_LIMIT)
- midiData[52+(6*noteCount+1)] = MIDI_LIMIT;
+ if (midiData[52 + (6 * noteCount + 1)] > MIDI_LIMIT)
+ midiData[52 + (6 * noteCount + 1)] = MIDI_LIMIT;
- if((midiData[52+(6*(noteCount-1)+1)] == 0 || midiData[52+(6*(noteCount-1)+1)] == 7) && Melody[0].vol == '-')
- midiData[52+(6*noteCount+1)] = 0;
+ if ((midiData[52 + (6 * (noteCount - 1) + 1)] == 0 || midiData[52 + (6 * (noteCount - 1) + 1)] == 7) && Melody[0].vol == '-')
+ midiData[52 + (6 * noteCount + 1)] = 0;
}
- else
- if(Melody[0].vol == '%' && vol == '%' && repeat != 0)
- midiData[52+(6*noteCount+1)] = midiData[52+(6*(noteCount-1)+1)];
+ else if (Melody[0].vol == '%' && vol == '%' && repeat != 0)
+ midiData[52 + (6 * noteCount + 1)] = midiData[52 + (6 * (noteCount - 1) + 1)];
- volInterval = midiData[52+(6*noteCount+1)] - midiData[53];
+ volInterval = midiData[52 + (6 * noteCount + 1)] - midiData[53];
- for(repeatCount = 0;repeatCount < repeat;repeatCount++)
- for(number = 6 * noteCount * repeatCount + 1;number < 6 * noteCount * (repeatCount + 1);number = number + 6)
- {
- midiData[52+(number+6*noteCount)] = midiData[52+number] + volInterval;
+ for (repeatCount = 0; repeatCount < repeat; repeatCount++)
+ for (number = 6 * noteCount * repeatCount + 1; number < 6 * noteCount * (repeatCount + 1); number = number + 6) {
+ midiData[52 + (number + 6 * noteCount)] = midiData[52 + number] + volInterval;
- if(midiData[52+number] + volInterval > MIDI_LIMIT)
- midiData[52+(number+6*noteCount)] = MIDI_LIMIT;
+ if (midiData[52 + number] + volInterval > MIDI_LIMIT)
+ midiData[52 + (number + 6 * noteCount)] = MIDI_LIMIT;
- if(midiData[52+number] < volInterval * (-1))
- midiData[52+(number+6*noteCount)] = 0;
+ if (midiData[52 + number] < volInterval * (-1))
+ midiData[52 + (number + 6 * noteCount)] = 0;
}
- for(number = 1;number < 6 * noteCount * (repeat + 1);number = number + 6)
- {
- if(midiData[52+number] > MIDI_LIMIT)
- midiData[52+number] = MIDI_LIMIT;
+ for (number = 1; number < 6 * noteCount * (repeat + 1); number = number + 6) {
+ if (midiData[52 + number] > MIDI_LIMIT)
+ midiData[52 + number] = MIDI_LIMIT;
}
pMelodyBuf = pMelodyStart;
count = noteCount;
- if(repeat != 0)
- {
- while(*pMelodyBuf != '@')
+ if (repeat != 0) {
+ while (*pMelodyBuf != '@')
pMelodyBuf++;
-
+
pMelodyBuf++;
- if(vol !='%')
+ if (vol != '%')
pMelodyBuf = pMelodyBuf + 2;
- while(!(*pMelodyBuf == '*' || *pMelodyBuf == '#' || *pMelodyBuf == '&' || *pMelodyBuf == 'r' || *pMelodyBuf == 'V' || *pMelodyBuf == 'E' || (*pMelodyBuf >= 'a' && *pMelodyBuf <= 'g')))
+ while (!(*pMelodyBuf == '*' || *pMelodyBuf == '#' || *pMelodyBuf == '&' || *pMelodyBuf == 'r' || *pMelodyBuf == 'V' || *pMelodyBuf == 'E' || (*pMelodyBuf >= 'a' && *pMelodyBuf <= 'g')))
pMelodyBuf++;
}
- if(*pMelodyBuf != 'E' && *pMelodyBuf != ':')
- {
+ if (*pMelodyBuf != 'E' && *pMelodyBuf != ':') {
pMelodyBuf--;
- while(*pMelodyBuf != 'E')
- {
- if(noteCount>=AV_MIDI_NOTE_MAX)
- {
- debug_warning ("__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
+ while (*pMelodyBuf != 'E') {
+ if (noteCount >= AV_MIDI_NOTE_MAX) {
+ debug_warning("__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
break;
}
-
+
pMelodyBuf++;
-
- if(*pMelodyBuf == '*')
- {
+
+ if (*pMelodyBuf == '*') {
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '8')
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '8')
octave[noteCount] = *pMelodyBuf;
}
- if(*pMelodyBuf == '#' || *pMelodyBuf == '&')
+ if (*pMelodyBuf == '#' || *pMelodyBuf == '&')
Melody[noteCount].flat_sharp = *pMelodyBuf;
- if(*pMelodyBuf == 'r')
- {
+ if (*pMelodyBuf == 'r') {
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '5')
- {
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '5') {
Melody[noteCount].rest = *pMelodyBuf;
pMelodyBuf++;
- if(*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
+ if (*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
Melody[noteCount].rest_specifier = *pMelodyBuf;
}
}
-
- if(*pMelodyBuf == 'V')
- {
+
+ if (*pMelodyBuf == 'V') {
pMelodyBuf++;
- if(*pMelodyBuf == '+' || *pMelodyBuf == '-')
+ if (*pMelodyBuf == '+' || *pMelodyBuf == '-')
Melody[noteCount].vol = *pMelodyBuf;
}
- if(*pMelodyBuf >= 'a' && *pMelodyBuf <= 'g')
- {
+ if (*pMelodyBuf >= 'a' && *pMelodyBuf <= 'g') {
Melody[noteCount].note = *pMelodyBuf;
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '5')
- {
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '5') {
Melody[noteCount].duration = *pMelodyBuf;
pMelodyBuf++;
- if(*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
+ if (*pMelodyBuf == '.' || *pMelodyBuf == ':' || *pMelodyBuf == ';')
Melody[noteCount].duration_specifier = *pMelodyBuf;
else
}
}
- for(octaveCount = count; octaveCount < noteCount && octaveCount < AV_MIDI_NOTE_MAX; octaveCount++)
- {
- if(octave[octaveCount] == '%')
- octave[octaveCount] = octave[octaveCount-1];
+ for (octaveCount = count; octaveCount < noteCount && octaveCount < AV_MIDI_NOTE_MAX; octaveCount++) {
+ if (octave[octaveCount] == '%')
+ octave[octaveCount] = octave[octaveCount - 1];
}
- for(number = count; number < noteCount && number < AV_MIDI_NOTE_MAX; number++)
- {
+ for (number = count; number < noteCount && number < AV_MIDI_NOTE_MAX; number++) {
octaveValue = octave[number] - '0';
octaveValue = octaveValue * 12;
- if(Melody[number].flat_sharp == '#')
- {
- switch(Melody[number].note)
- {
- case 'c': noteData[number].note = octaveValue + 1;
- break;
- case 'd': noteData[number].note = octaveValue + 3;
- break;
- case 'f': noteData[number].note = octaveValue + 6;
- break;
- case 'g': noteData[number].note = octaveValue + 8;
- break;
- case 'a': noteData[number].note = octaveValue + 10;
- break;
- default :
- break;
+ if (Melody[number].flat_sharp == '#') {
+ switch (Melody[number].note) {
+ case 'c':
+ noteData[number].note = octaveValue + 1;
+ break;
+ case 'd':
+ noteData[number].note = octaveValue + 3;
+ break;
+ case 'f':
+ noteData[number].note = octaveValue + 6;
+ break;
+ case 'g':
+ noteData[number].note = octaveValue + 8;
+ break;
+ case 'a':
+ noteData[number].note = octaveValue + 10;
+ break;
+ default:
+ break;
}
}
- else
- if(Melody[number].flat_sharp == '&')
- {
- switch(Melody[number].note)
- {
- case 'd': noteData[number].note = octaveValue + 1;
- break;
- case 'e': noteData[number].note = octaveValue + 3;
- break;
- case 'g': noteData[number].note = octaveValue + 6;
- break;
- case 'a': noteData[number].note = octaveValue + 8;
- break;
- case 'b': noteData[number].note = octaveValue + 10;
- break;
- default :
- break;
+ else if (Melody[number].flat_sharp == '&') {
+ switch (Melody[number].note) {
+ case 'd':
+ noteData[number].note = octaveValue + 1;
+ break;
+ case 'e':
+ noteData[number].note = octaveValue + 3;
+ break;
+ case 'g':
+ noteData[number].note = octaveValue + 6;
+ break;
+ case 'a':
+ noteData[number].note = octaveValue + 8;
+ break;
+ case 'b':
+ noteData[number].note = octaveValue + 10;
+ break;
+ default:
+ break;
}
}
- else
- {
- switch(Melody[number].note)
- {
- case 'c': noteData[number].note = octaveValue;
- break;
- case 'd': noteData[number].note = octaveValue + 2;
- break;
- case 'e': noteData[number].note = octaveValue + 4;
- break;
- case 'f': noteData[number].note = octaveValue + 5;
- break;
- case 'g': noteData[number].note = octaveValue + 7;
- break;
- case 'a': noteData[number].note = octaveValue + 9;
- break;
- case 'b': noteData[number].note = octaveValue + 11;
- break;
- default :
- break;
+ else {
+ switch (Melody[number].note) {
+ case 'c':
+ noteData[number].note = octaveValue;
+ break;
+ case 'd':
+ noteData[number].note = octaveValue + 2;
+ break;
+ case 'e':
+ noteData[number].note = octaveValue + 4;
+ break;
+ case 'f':
+ noteData[number].note = octaveValue + 5;
+ break;
+ case 'g':
+ noteData[number].note = octaveValue + 7;
+ break;
+ case 'a':
+ noteData[number].note = octaveValue + 9;
+ break;
+ case 'b':
+ noteData[number].note = octaveValue + 11;
+ break;
+ default:
+ break;
}
}
- if(style == '0')
- {
- switch(Melody[number].duration)
- {
- case '0': noteData[number].duration_on = 183;
- noteData[number].duration_off = 9;
- break;
- case '1': noteData[number].duration_on = 91;
- noteData[number].duration_off = 5;
- break;
- case '2': noteData[number].duration_on = 46;
- noteData[number].duration_off = 2;
- break;
- case '3': noteData[number].duration_on = 23;
- noteData[number].duration_off = 1;
- break;
- case '4': noteData[number].duration_on = 11;
- noteData[number].duration_off = 1;
- break;
- case '5': noteData[number].duration_on = 5;
- noteData[number].duration_off = 1;
- break;
- default :
- break;
+ if (style == '0') {
+ switch (Melody[number].duration) {
+ case '0':
+ noteData[number].duration_on = 183;
+ noteData[number].duration_off = 9;
+ break;
+ case '1':
+ noteData[number].duration_on = 91;
+ noteData[number].duration_off = 5;
+ break;
+ case '2':
+ noteData[number].duration_on = 46;
+ noteData[number].duration_off = 2;
+ break;
+ case '3':
+ noteData[number].duration_on = 23;
+ noteData[number].duration_off = 1;
+ break;
+ case '4':
+ noteData[number].duration_on = 11;
+ noteData[number].duration_off = 1;
+ break;
+ case '5':
+ noteData[number].duration_on = 5;
+ noteData[number].duration_off = 1;
+ break;
+ default:
+ break;
}
}
- else
- if(style == '1')
- {
- switch(Melody[number].duration)
- {
- case '0': noteData[number].duration_on = 192;
- noteData[number].duration_off = 0;
- break;
- case '1': noteData[number].duration_on = 96;
- noteData[number].duration_off = 0;
- break;
- case '2': noteData[number].duration_on = 48;
- noteData[number].duration_off = 0;
- break;
- case '3': noteData[number].duration_on = 24;
- noteData[number].duration_off = 0;
- break;
- case '4': noteData[number].duration_on = 12;
- noteData[number].duration_off = 0;
- break;
- case '5': noteData[number].duration_on = 6;
- noteData[number].duration_off = 0;
- break;
- default :
- break;
+ else if (style == '1') {
+ switch (Melody[number].duration) {
+ case '0':
+ noteData[number].duration_on = 192;
+ noteData[number].duration_off = 0;
+ break;
+ case '1':
+ noteData[number].duration_on = 96;
+ noteData[number].duration_off = 0;
+ break;
+ case '2':
+ noteData[number].duration_on = 48;
+ noteData[number].duration_off = 0;
+ break;
+ case '3':
+ noteData[number].duration_on = 24;
+ noteData[number].duration_off = 0;
+ break;
+ case '4':
+ noteData[number].duration_on = 12;
+ noteData[number].duration_off = 0;
+ break;
+ case '5':
+ noteData[number].duration_on = 6;
+ noteData[number].duration_off = 0;
+ break;
+ default:
+ break;
}
}
- else
- {
- switch(Melody[number].duration)
- {
- case '0': noteData[number].duration_on = 96;
- noteData[number].duration_off = 96;
- break;
- case '1': noteData[number].duration_on = 48;
- noteData[number].duration_off = 48;
- break;
- case '2': noteData[number].duration_on = 24;
- noteData[number].duration_off = 24;
- break;
- case '3': noteData[number].duration_on = 12;
- noteData[number].duration_off = 12;
- break;
- case '4': noteData[number].duration_on = 6;
- noteData[number].duration_off = 6;
- break;
- case '5': noteData[number].duration_on = 3;
- noteData[number].duration_off = 3;
- break;
- default :
- break;
+ else {
+ switch (Melody[number].duration) {
+ case '0':
+ noteData[number].duration_on = 96;
+ noteData[number].duration_off = 96;
+ break;
+ case '1':
+ noteData[number].duration_on = 48;
+ noteData[number].duration_off = 48;
+ break;
+ case '2':
+ noteData[number].duration_on = 24;
+ noteData[number].duration_off = 24;
+ break;
+ case '3':
+ noteData[number].duration_on = 12;
+ noteData[number].duration_off = 12;
+ break;
+ case '4':
+ noteData[number].duration_on = 6;
+ noteData[number].duration_off = 6;
+ break;
+ case '5':
+ noteData[number].duration_on = 3;
+ noteData[number].duration_off = 3;
+ break;
+ default:
+ break;
}
}
- switch(Melody[number].duration)
- {
- case '0': durationSpec[number] = 192;
- break;
- case '1': durationSpec[number] = 96;
- break;
- case '2': durationSpec[number] = 48;
- break;
- case '3': durationSpec[number] = 24;
- break;
- case '4': durationSpec[number] = 12;
- break;
- case '5': durationSpec[number] = 6;
- break;
- default :
- break;
+ switch (Melody[number].duration) {
+ case '0':
+ durationSpec[number] = 192;
+ break;
+ case '1':
+ durationSpec[number] = 96;
+ break;
+ case '2':
+ durationSpec[number] = 48;
+ break;
+ case '3':
+ durationSpec[number] = 24;
+ break;
+ case '4':
+ durationSpec[number] = 12;
+ break;
+ case '5':
+ durationSpec[number] = 6;
+ break;
+ default:
+ break;
}
- if(Melody[number].duration_specifier != '%')
- {
- switch(Melody[number].duration_specifier)
- {
- case '.': noteData[number].duration_on += (durationSpec[number] / 2);
- break;
- case ':': noteData[number].duration_on += durationSpec[number];
- break;
- case ';': noteData[number].duration_on -= (durationSpec[number] / 3);
- break;
- default :
- break;
+ if (Melody[number].duration_specifier != '%') {
+ switch (Melody[number].duration_specifier) {
+ case '.':
+ noteData[number].duration_on += (durationSpec[number] / 2);
+ break;
+ case ':':
+ noteData[number].duration_on += durationSpec[number];
+ break;
+ case ';':
+ noteData[number].duration_on -= (durationSpec[number] / 3);
+ break;
+ default:
+ break;
}
- if(noteData[number].duration_on > MIDI_MAX)
- noteData[number].duration_on = MIDI_LIMIT;
+ if (noteData[number].duration_on > MIDI_MAX)
+ noteData[number].duration_on = MIDI_LIMIT;
}
}
- for(number = count + 1; number < noteCount && number < AV_MIDI_NOTE_MAX; number++)
- {
- if(Melody[number].rest >= '0' && Melody[number].rest <= '5')
- {
- switch(Melody[number].rest)
- {
- case '0': noteData[number-1].duration_off += 192;
- restSpec[number] = 192;
- break;
- case '1': noteData[number-1].duration_off += 96;
- restSpec[number] = 96;
- break;
- case '2': noteData[number-1].duration_off += 48;
- restSpec[number] = 48;
- break;
- case '3': noteData[number-1].duration_off += 24;
- restSpec[number] = 24;
- break;
- case '4': noteData[number-1].duration_off += 12;
- restSpec[number] = 12;
- break;
- case '5': noteData[number-1].duration_off += 6;
- restSpec[number] = 6;
- break;
- default :
- break;
+ for (number = count + 1; number < noteCount && number < AV_MIDI_NOTE_MAX; number++) {
+ if (Melody[number].rest >= '0' && Melody[number].rest <= '5') {
+ switch (Melody[number].rest) {
+ case '0':
+ noteData[number - 1].duration_off += 192;
+ restSpec[number] = 192;
+ break;
+ case '1':
+ noteData[number - 1].duration_off += 96;
+ restSpec[number] = 96;
+ break;
+ case '2':
+ noteData[number - 1].duration_off += 48;
+ restSpec[number] = 48;
+ break;
+ case '3':
+ noteData[number - 1].duration_off += 24;
+ restSpec[number] = 24;
+ break;
+ case '4':
+ noteData[number - 1].duration_off += 12;
+ restSpec[number] = 12;
+ break;
+ case '5':
+ noteData[number - 1].duration_off += 6;
+ restSpec[number] = 6;
+ break;
+ default:
+ break;
}
- if(noteData[number-1].duration_off > MIDI_MAX && Melody[number].rest_specifier == '%')
- noteData[number-1].duration_off = MIDI_LIMIT;
+ if (noteData[number - 1].duration_off > MIDI_MAX && Melody[number].rest_specifier == '%')
+ noteData[number - 1].duration_off = MIDI_LIMIT;
}
- if(Melody[number].rest_specifier != '%')
- {
- switch(Melody[number].rest_specifier)
- {
- case '.': noteData[number-1].duration_off += (restSpec[number] / 2);
- break;
- case ':': noteData[number-1].duration_off += restSpec[number];
- break;
- case ';': noteData[number-1].duration_off -= (restSpec[number] / 3);
- break;
- default :
- break;
+ if (Melody[number].rest_specifier != '%') {
+ switch (Melody[number].rest_specifier) {
+ case '.':
+ noteData[number - 1].duration_off += (restSpec[number] / 2);
+ break;
+ case ':':
+ noteData[number - 1].duration_off += restSpec[number];
+ break;
+ case ';':
+ noteData[number - 1].duration_off -= (restSpec[number] / 3);
+ break;
+ default:
+ break;
}
- if(noteData[number-1].duration_off > MIDI_MAX)
- noteData[number-1].duration_off = MIDI_LIMIT;
+ if (noteData[number - 1].duration_off > MIDI_MAX)
+ noteData[number - 1].duration_off = MIDI_LIMIT;
}
}
- if(Melody[count].rest >= '0' && Melody[count].rest <= '5')
- {
- switch(Melody[count].rest)
- {
- case '0': midiData[52+(6*count*(repeat+1)-1)] += 192;
- restSpec[count] = 192;
- break;
- case '1': midiData[52+(6*count*(repeat+1)-1)] += 96;
- restSpec[count] = 96;
- break;
- case '2': midiData[52+(6*count*(repeat+1)-1)] += 48;
- restSpec[count] = 48;
- break;
- case '3': midiData[52+(6*count*(repeat+1)-1)] += 24;
- restSpec[count] = 24;
- break;
- case '4': midiData[52+(6*count*(repeat+1)-1)] += 12;
- restSpec[count] = 12;
- break;
- case '5': midiData[52+(6*count*(repeat+1)-1)] += 6;
- restSpec[count] = 6;
- break;
- default :
- break;
+ if (Melody[count].rest >= '0' && Melody[count].rest <= '5') {
+ switch (Melody[count].rest) {
+ case '0':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += 192;
+ restSpec[count] = 192;
+ break;
+ case '1':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += 96;
+ restSpec[count] = 96;
+ break;
+ case '2':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += 48;
+ restSpec[count] = 48;
+ break;
+ case '3':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += 24;
+ restSpec[count] = 24;
+ break;
+ case '4':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += 12;
+ restSpec[count] = 12;
+ break;
+ case '5':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += 6;
+ restSpec[count] = 6;
+ break;
+ default:
+ break;
}
- if(Melody[count].rest_specifier != '%')
- {
- switch(Melody[count].rest_specifier)
- {
- case '.': midiData[52+(6*count*(repeat+1)-1)] += (restSpec[count] / 2);
- break;
- case ':': midiData[52+(6*count*(repeat+1)-1)] += restSpec[count];
- break;
- case ';': midiData[52+(6*count*(repeat+1)-1)] -= (restSpec[count] / 3);
- break;
- default :
- break;
+ if (Melody[count].rest_specifier != '%') {
+ switch (Melody[count].rest_specifier) {
+ case '.':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += (restSpec[count] / 2);
+ break;
+ case ':':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] += restSpec[count];
+ break;
+ case ';':
+ midiData[52 + (6 * count * (repeat + 1) - 1)] -= (restSpec[count] / 3);
+ break;
+ default:
+ break;
}
}
- if(midiData[52+(6*count*(repeat+1)-1)] > MIDI_LIMIT)
- midiData[52+(6*count*(repeat+1)-1)] = MIDI_LIMIT;
+ if (midiData[52 + (6 * count * (repeat + 1) - 1)] > MIDI_LIMIT)
+ midiData[52 + (6 * count * (repeat + 1) - 1)] = MIDI_LIMIT;
- if(Melody[count].rest == '0')
- midiData[52+(6*count*(repeat+1)-1)] = MIDI_LIMIT;
+ if (Melody[count].rest == '0')
+ midiData[52 + (6 * count * (repeat + 1) - 1)] = MIDI_LIMIT;
}
- for(number = count;number < noteCount;number++)
- {
+ for (number = count; number < noteCount; number++) {
noteBase[0] = noteData[number].note;
noteBase[2] = noteData[number].duration_on;
noteBase[3] = noteData[number].note;
noteBase[5] = noteData[number].duration_off;
- noteTotal[6*number] = noteBase[0];
- noteTotal[6*number+2] = noteBase[2];
- noteTotal[6*number+3] = noteBase[3];
- noteTotal[6*number+5] = noteBase[5];
- noteTotal[6*number+4] = 0;
+ noteTotal[6 * number] = noteBase[0];
+ noteTotal[6 * number + 2] = noteBase[2];
+ noteTotal[6 * number + 3] = noteBase[3];
+ noteTotal[6 * number + 5] = noteBase[5];
+ noteTotal[6 * number + 4] = 0;
- if(noteTotal[6*number+2] > MIDI_LIMIT)
- noteTotal[6*number+2] = MIDI_LIMIT;
+ if (noteTotal[6 * number + 2] > MIDI_LIMIT)
+ noteTotal[6 * number + 2] = MIDI_LIMIT;
- if(noteTotal[6*number+5] > MIDI_LIMIT)
- noteTotal[6*number+5] = MIDI_LIMIT;
+ if (noteTotal[6 * number + 5] > MIDI_LIMIT)
+ noteTotal[6 * number + 5] = MIDI_LIMIT;
}
- for(number = count + 1;number < noteCount;number++)
- {
- noteTotal[6*count+1] = midiData[52+(6*count*(repeat+1)-5)];
+ for (number = count + 1; number < noteCount; number++) {
+ noteTotal[6 * count + 1] = midiData[52 + (6 * count * (repeat + 1) - 5)];
- if(Melody[count].vol == '+')
- noteTotal[6*count+1] = noteTotal[6*count+1] + VOL_INTERVAL;
+ if (Melody[count].vol == '+')
+ noteTotal[6 * count + 1] = noteTotal[6 * count + 1] + VOL_INTERVAL;
- if(Melody[count].vol == '-' && (noteTotal[6*count+1] == 0 || noteTotal[6*count+1] == 7))
- noteTotal[6*count+1] = 0;
+ if (Melody[count].vol == '-' && (noteTotal[6 * count + 1] == 0 || noteTotal[6 * count + 1] == 7))
+ noteTotal[6 * count + 1] = 0;
- if(Melody[count].vol == '-' && noteTotal[6*count+1] >= 12)
- noteTotal[6*count+1] = noteTotal[6*count+1] - VOL_INTERVAL;
+ if (Melody[count].vol == '-' && noteTotal[6 * count + 1] >= 12)
+ noteTotal[6 * count + 1] = noteTotal[6 * count + 1] - VOL_INTERVAL;
- if(noteTotal[6*count+1] > MIDI_LIMIT)
- noteTotal[6*count+1] = MIDI_LIMIT;
+ if (noteTotal[6 * count + 1] > MIDI_LIMIT)
+ noteTotal[6 * count + 1] = MIDI_LIMIT;
- switch(Melody[number].vol)
- {
- case '+': noteTotal[6*number+1] = noteTotal[6*(number-1)+1] + VOL_INTERVAL;
- break;
- case '-': noteTotal[6*number+1] = noteTotal[6*(number-1)+1] - VOL_INTERVAL;
- break;
- default :
- break;
+ switch (Melody[number].vol) {
+ case '+':
+ noteTotal[6 * number + 1] = noteTotal[6 * (number - 1) + 1] + VOL_INTERVAL;
+ break;
+ case '-':
+ noteTotal[6 * number + 1] = noteTotal[6 * (number - 1) + 1] - VOL_INTERVAL;
+ break;
+ default:
+ break;
}
- if(noteTotal[6*number+1] > MIDI_LIMIT)
- noteTotal[6*number+1] = MIDI_LIMIT;
+ if (noteTotal[6 * number + 1] > MIDI_LIMIT)
+ noteTotal[6 * number + 1] = MIDI_LIMIT;
- if((noteTotal[6*(number-1)+1] == 0 || noteTotal[6*(number-1)+1] == 7) && Melody[number].vol == '-')
- noteTotal[6*number+1] = 0;
+ if ((noteTotal[6 * (number - 1) + 1] == 0 || noteTotal[6 * (number - 1) + 1] == 7) && Melody[number].vol == '-')
+ noteTotal[6 * number + 1] = 0;
- if(Melody[number].vol == '%')
- noteTotal[6*number+1] = noteTotal[6*(number-1)+1];
+ if (Melody[number].vol == '%')
+ noteTotal[6 * number + 1] = noteTotal[6 * (number - 1) + 1];
}
numberCount = 6 * count;
- for(number = 6 * count * (repeat + 1);number < 6 * (count * (repeat + 1) + (noteCount - count));number++)
- {
- midiData[52+number] = noteTotal[numberCount];
+ for (number = 6 * count * (repeat + 1); number < 6 * (count * (repeat + 1) + (noteCount - count)); number++) {
+ midiData[52 + number] = noteTotal[numberCount];
numberCount++;
}
}
- noteTotal[6*(count*(repeat+1)+(noteCount-count))] = 0; //0x00
- noteTotal[6*(count*(repeat+1)+(noteCount-count))+1] = MIDI_MAX; //0xff
- noteTotal[6*(count*(repeat+1)+(noteCount-count))+2] = 47; //0x2f
- noteTotal[6*(count*(repeat+1)+(noteCount-count))+3] = 0; //0x00
+ noteTotal[6 * (count * (repeat + 1) + (noteCount - count))] = 0; /*0x00 */
+ noteTotal[6 * (count * (repeat + 1) + (noteCount - count)) + 1] = MIDI_MAX; /*0xff */
+ noteTotal[6 * (count * (repeat + 1) + (noteCount - count)) + 2] = 47; /*0x2f */
+ noteTotal[6 * (count * (repeat + 1) + (noteCount - count)) + 3] = 0; /*0x00 */
- for(number = 6 * (count * (repeat + 1) + (noteCount - count));number <= 6 * (count * (repeat + 1) + (noteCount - count)) + 3;number++)
- midiData[51+number] = noteTotal[number];
+ for (number = 6 * (count * (repeat + 1) + (noteCount - count)); number <= 6 * (count * (repeat + 1) + (noteCount - count)) + 3; number++)
+ midiData[51 + number] = noteTotal[number];
- trackSize = (6 * (count * (repeat + 1) + (noteCount - count)) + 56) - 22 -1 ;
+ trackSize = (6 * (count * (repeat + 1) + (noteCount - count)) + 56) - 22 - 1 ;
midiData[20] = (trackSize & 0xff00) >> 8;
midiData[21] = (trackSize & 0x00ff);
- *pBufLen = 6 * (count * (repeat + 1) + (noteCount - count)) + 56 -1;
+ *pBufLen = 6 * (count * (repeat + 1) + (noteCount - count)) + 56 - 1;
- pConvertBuf = (unsigned char*) mmfile_malloc (*pBufLen);
- if(pConvertBuf == NULL)
- {
- debug_error ("__AvConvertIMelody2MIDI: malloc failed!\n");
+ pConvertBuf = (unsigned char *) mmfile_malloc(*pBufLen);
+ if (pConvertBuf == NULL) {
+ debug_error("__AvConvertIMelody2MIDI: malloc failed!\n");
return NULL;
}
}
static unsigned char
-__AvMIDISetVolume(char* pMelodyBuf)
+__AvMIDISetVolume(char *pMelodyBuf)
{
unsigned char midiVol;
pMelodyBuf = pMelodyBuf + 42;
- while(!((*pMelodyBuf == 'V' && (*(pMelodyBuf+1) < 'a' || *(pMelodyBuf+1) > 'z')) || (*pMelodyBuf == 'M' && *(pMelodyBuf+5) == 'Y' && *(pMelodyBuf+6) == ':'))) //2007-02-28 AVMS_Sound:k2bogus - UMTS200073205;imy play, [MELODY:] extract fix
+ while (!((*pMelodyBuf == 'V' && (*(pMelodyBuf + 1) < 'a' || *(pMelodyBuf + 1) > 'z')) || (*pMelodyBuf == 'M' && *(pMelodyBuf + 5) == 'Y' && *(pMelodyBuf + 6) == ':'))) /*2007-02-28 AVMS_Sound:k2bogus - UMTS200073205;imy play, [MELODY:] extract fix */
pMelodyBuf++;
- if(*pMelodyBuf != 'V')
+ if (*pMelodyBuf != 'V')
midiVol = AV_MIDI_VOL_MAX;
- else
- {
+ else {
pMelodyBuf = pMelodyBuf + 5;
- if(*pMelodyBuf == 'E')
+ if (*pMelodyBuf == 'E')
pMelodyBuf = pMelodyBuf + 3;
else
pMelodyBuf = pMelodyBuf - 4;
- if(*pMelodyBuf == '1')
- {
+ if (*pMelodyBuf == '1') {
pMelodyBuf++;
- switch(*pMelodyBuf)
- {
- case '0': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '1': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '2': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '3': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '4': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '5': midiVol = AV_MIDI_VOL_MAX;
- break;
- default : midiVol = AV_MIDI_VOL_MAX;
- break;
+ switch (*pMelodyBuf) {
+ case '0':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '1':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '2':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '3':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '4':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '5':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ default:
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
}
}
else
- switch(*pMelodyBuf)
- {
- case '0': midiVol = 0;
- break;
- case '2': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '3': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '4': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '5': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '6': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '7': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '8': midiVol = AV_MIDI_VOL_MAX;
- break;
- case '9': midiVol = AV_MIDI_VOL_MAX;
- break;
- default : midiVol = AV_MIDI_VOL_MAX;
- break;
- }
+ switch (*pMelodyBuf) {
+ case '0':
+ midiVol = 0;
+ break;
+ case '2':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '3':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '4':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '5':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '6':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '7':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '8':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ case '9':
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ default:
+ midiVol = AV_MIDI_VOL_MAX;
+ break;
+ }
}
return midiVol;
}
static int
-__AvMIDISetBeat(char* pMelodyBuf)
+__AvMIDISetBeat(char *pMelodyBuf)
{
int bpmValue[4] = {0};
int beatValue;
pMelodyBuf = pMelodyBuf + 42;
- while(!((*pMelodyBuf == 'B' && (*(pMelodyBuf+1) < 'a' || *(pMelodyBuf+1) > 'z')) || (*pMelodyBuf == 'M' && *(pMelodyBuf+5) == 'Y' && *(pMelodyBuf+6) == ':'))) //2007-02-28 AVMS_Sound:k2bogus - UMTS200073205;imy play, [MELODY:] extract fix
+ while (!((*pMelodyBuf == 'B' && (*(pMelodyBuf + 1) < 'a' || *(pMelodyBuf + 1) > 'z')) || (*pMelodyBuf == 'M' && *(pMelodyBuf + 5) == 'Y' && *(pMelodyBuf + 6) == ':'))) /*2007-02-28 AVMS_Sound:k2bogus - UMTS200073205;imy play, [MELODY:] extract fix */
pMelodyBuf++;
- if(*pMelodyBuf != 'B')
+ if (*pMelodyBuf != 'B')
bpmValue[3] = 120;
- else
- {
+ else {
pMelodyBuf = pMelodyBuf + 4;
- if(*pMelodyBuf == ':')
- {
+ if (*pMelodyBuf == ':') {
pMelodyBuf++;
- if(*pMelodyBuf >= '1' && *pMelodyBuf <= '9')
- {
+ if (*pMelodyBuf >= '1' && *pMelodyBuf <= '9') {
bpmValue[0] = *pMelodyBuf - '0';
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '9')
- {
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '9') {
bpmValue[1] = *pMelodyBuf - '0';
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '9')
- {
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '9') {
bpmValue[2] = *pMelodyBuf - '0';
bpmValue[0] = bpmValue[0] * 100;
}
}
- if(bpmValue[3] < 25 || bpmValue[3] > 900)
+ if (bpmValue[3] < 25 || bpmValue[3] > 900)
bpmValue[3] = 120;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '9')
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '9')
bpmValue[3] = 120;
beatValue = 1000000 * 60 / bpmValue[3];
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("beat: %d = 1000000 * 60 / %d\n", beatValue, bpmValue[3]);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("beat: %d = 1000000 * 60 / %d\n", beatValue, bpmValue[3]);
+#endif
return beatValue;
}
static char
-__AvMIDISetStyle(char* pMelodyBuf)
+__AvMIDISetStyle(char *pMelodyBuf)
{
char styleValue = '0';
- while(*pMelodyBuf != 'S')
+ while (*pMelodyBuf != 'S')
pMelodyBuf--;
pMelodyBuf++;
- if(*pMelodyBuf >= '0' && *pMelodyBuf <= '2')
+ if (*pMelodyBuf >= '0' && *pMelodyBuf <= '2')
pMelodyBuf++;
- if(*pMelodyBuf != '.')
- {
+ if (*pMelodyBuf != '.') {
pMelodyBuf--;
styleValue = *pMelodyBuf;
}
- if(styleValue < '0' || styleValue > '2') {
- debug_warning ("unknown style. use default(S0)\n");
+ if (styleValue < '0' || styleValue > '2') {
+ debug_warning("unknown style. use default(S0)\n");
styleValue = '0';
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("style: '%c'\n", styleValue);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("style: '%c'\n", styleValue);
+#endif
return styleValue;
}
#define MAX_SMF_MESSAGES 256 /* */
#define MAX_SMF_TRACKS 32 /* Should be <= 32 */
#define SMF_MAX_GAIN 76 /* - 6[dB] : 90 */
- /* -18[dB] : 45 */
+/* -18[dB] : 45 */
#define MINIMUM_LENGTH (20)
#define MELODY_MAP (0)
/*--------------------------------------------------------------------------*/
/* Types */
/*--------------------------------------------------------------------------*/
-typedef struct _tagMidChInfo
-{
+typedef struct _tagMidChInfo {
UINT32 dBank; /* BankH&L (0x00:00..0x7F7F) */
UINT32 dCurrBank; /* BankH&L (0x00:00..0x7F7F) */
UINT32 dProg; /* ProgramChange (0..127) */
UINT32 dCoaseTune; /* 0..0x7F */
} MIDCHINFO, *PMIDCHINFO;
-typedef struct _tagMIDPACKET
-{
+typedef struct _tagMIDPACKET {
SINT32 sdDeltaTime;
- UINT32 dMsgID;
- UINT32 dP1;
- UINT32 dP2;
- UINT32 dP3;
+ UINT32 dMsgID;
+ UINT32 dP1;
+ UINT32 dP2;
+ UINT32 dP3;
} MIDPACKET, *PMIDPACKET;
-typedef struct _tagTrack
-{
+typedef struct _tagTrack {
UINT32 dSmfCmd; /* CMD @ now */
UINT32 dSize; /* [byte] 0 measns nothing in it. */
- UINT8* pbBase; /* NULL measns nothing in it. */
+ UINT8 *pbBase; /* NULL measns nothing in it. */
UINT32 dOffset; /* offset byte */
SINT32 sdTicks; /* */
} TRACKINFO, *PTRACKINFO;
-typedef struct _tagOrderList
-{
- struct _tagOrderList* pPrev;
- struct _tagOrderList* pNext;
+typedef struct _tagOrderList {
+ struct _tagOrderList *pPrev;
+ struct _tagOrderList *pNext;
UINT32 dTrack;
UINT32 dTicks;
} ORDERLIST, *PORDERLIST;
-typedef struct _tagMidInfo
-{
+typedef struct _tagMidInfo {
UINT32 dTimeResolution; /* 0..0x7fff */
- UINT8* pbText; /* */
+ UINT8 *pbText; /* */
UINT32 dSizeText; /* */
- UINT8* pbTitle; /* */
+ UINT8 *pbTitle; /* */
UINT32 dSizeTitle; /* */
- UINT8* pbCopyright; /* */
+ UINT8 *pbCopyright; /* */
UINT32 dSizeCopyright; /* */
UINT32 dNumOfTracks; /* 1..32 */
UINT32 dSmfFormat; /* 0..1 */
SINT32 sdDelta; /* (22.10)[ms] */
UINT32 dEndFlag; /* */
- TRACKINFO TrackInfo[MAX_SMF_TRACKS];
-
- struct _tagOrderList* pTopOrderList;
- struct _tagOrderList* pDoneOrderList;
- struct _tagOrderList* pBottomOrderList;
+ TRACKINFO TrackInfo[MAX_SMF_TRACKS];
+
+ struct _tagOrderList *pTopOrderList;
+ struct _tagOrderList *pDoneOrderList;
+ struct _tagOrderList *pBottomOrderList;
ORDERLIST OrderList[MAX_SMF_TRACKS + 3];
MIDCHINFO ChInfo[16]; /* */
UINT8 bVoiceMap[NUM_OF_MAPS][128];/* 0:Empty, 1:Valid */
} MIDINFO, *PMIDINFO;
-typedef struct _tagMidGlobals
-{
+typedef struct _tagMidGlobals {
SINT32 sdSeqID; /* Sequence ID */
SINT32 sdFileID; /* File ID */
UINT32 dEnable; /* 0:disable */
static PMIDINFO gPi;
-static SINT32 __AvMidFile_Initialize (void);
-static void __AvMidFile_Deinitialize (void);
-static void __AvMidInitializeOrderList (PMIDINFO pI);
-static void __AvMidSortOrderList (PMIDINFO pI);
-static void __AvMidInsertOrderList (PMIDINFO pI, UINT32 dTrack, SINT32 sdTicks);
-static void __AvMidRemoveFromOrderList (PMIDINFO pI);
-static SINT32 __AvMidGetTrackTime (PMIDINFO pI, UINT32 dTrack);
-static SINT32 __AvMidUpdateTrackTime (PMIDINFO pI, UINT32 dTrack);
-static void __AvMidResetTimeInfo (PMIDINFO pI);
-static SINT32 __AvMidGetLeastTimeTrack (PMIDINFO pI);
-static SINT32 __AvGetSizeOfFileInfo (PMIDINFO pI);
-static SINT32 __AvCheckSizeOfMidFile (UINT8* fp, UINT32 dFsize);
-static int __AvParseSkipXmf2Mid (UINT8* pbFile, UINT32 dFSize);
-static int __AvGetMidiDuration (char* szFileName, MIDI_INFO_SIMPLE *info);
+static SINT32 __AvMidFile_Initialize(void);
+static void __AvMidFile_Deinitialize(void);
+static void __AvMidInitializeOrderList(PMIDINFO pI);
+static void __AvMidSortOrderList(PMIDINFO pI);
+static void __AvMidInsertOrderList(PMIDINFO pI, UINT32 dTrack, SINT32 sdTicks);
+static void __AvMidRemoveFromOrderList(PMIDINFO pI);
+static SINT32 __AvMidGetTrackTime(PMIDINFO pI, UINT32 dTrack);
+static SINT32 __AvMidUpdateTrackTime(PMIDINFO pI, UINT32 dTrack);
+static void __AvMidResetTimeInfo(PMIDINFO pI);
+static SINT32 __AvMidGetLeastTimeTrack(PMIDINFO pI);
+static SINT32 __AvGetSizeOfFileInfo(PMIDINFO pI);
+static SINT32 __AvCheckSizeOfMidFile(UINT8 *fp, UINT32 dFsize);
+static int __AvParseSkipXmf2Mid(UINT8 *pbFile, UINT32 dFSize);
+static int __AvGetMidiDuration(char *szFileName, MIDI_INFO_SIMPLE *info);
/* mm plugin interface */
-int mmfile_format_read_stream_mid (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_mid (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_mid (MMFileFormatContext *formatContext);
-int mmfile_format_close_mid (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_mid(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_mid(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_mid(MMFileFormatContext *formatContext);
+int mmfile_format_close_mid(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_mid (MMFileFormatContext *formatContext)
+int mmfile_format_open_mid(MMFileFormatContext *formatContext)
{
int res = MMFILE_FORMAT_FAIL;
if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error ("error: mmfile_format_open_mid\n");
+ debug_error("error: mmfile_format_open_mid\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
- res = MMFileFormatIsValidMID (NULL, formatContext->uriFileName);
- if ( res == 0 ) {
+ res = MMFileFormatIsValidMID(NULL, formatContext->uriFileName);
+ if (res == 0) {
debug_error("It is not MIDI file\n");
return MMFILE_FORMAT_FAIL;
}
}
EXPORT_API
-int mmfile_format_read_stream_mid (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_mid(MMFileFormatContext *formatContext)
{
MMFileFormatStream *audioStream = NULL;
int ret = MMFILE_FORMAT_FAIL;
MIDI_INFO_SIMPLE *info = NULL;
if (NULL == formatContext) {
- debug_error ("error: invalid params\n");
+ debug_error("error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/*get infomation*/
- info = mmfile_format_get_midi_infomation (formatContext->uriFileName);
+ info = mmfile_format_get_midi_infomation(formatContext->uriFileName);
if (!info) {
- debug_error ("failed to get infomation");
+ debug_error("failed to get infomation");
goto exception;
}
formatContext->audioTotalTrackNum = info->track_num;
formatContext->nbStreams = 1;
- audioStream = mmfile_malloc (sizeof(MMFileFormatStream));
+ audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error ("error: mmfile_malloc audiostream\n");
+ debug_error("error: mmfile_malloc audiostream\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
audioStream->framePerSec = 0;
audioStream->width = 0;
audioStream->height = 0;
- audioStream->nbChannel = 1;
+ audioStream->nbChannel = 1;
audioStream->samplePerSec = 0;
formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
- #ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ mmfile_format_print_contents(formatContext);
+#endif
- mmfile_format_free_midi_infomation (info);
+ mmfile_format_free_midi_infomation(info);
return MMFILE_FORMAT_SUCCESS;
exception:
- mmfile_format_free_midi_infomation (info);
- mmfile_free (audioStream);
+ mmfile_format_free_midi_infomation(info);
+ mmfile_free(audioStream);
return ret;
}
EXPORT_API
-int mmfile_format_read_tag_mid (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_mid(MMFileFormatContext *formatContext)
{
- int ret= MMFILE_FORMAT_FAIL;
+ int ret = MMFILE_FORMAT_FAIL;
MIDI_INFO_SIMPLE *info = NULL;
- const char *locale = MMFileUtilGetLocale (NULL);
+ const char *locale = MMFileUtilGetLocale(NULL);
unsigned int tag_len;
unsigned int cnv_len;
if (NULL == formatContext) {
- debug_error ("error: invalid params\n");
+ debug_error("error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/*get infomation*/
- info = mmfile_format_get_midi_infomation (formatContext->uriFileName);
+ info = mmfile_format_get_midi_infomation(formatContext->uriFileName);
if (!info) {
- debug_error ("failed to get infomation");
+ debug_error("failed to get infomation");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
* UTF8 converting.
*/
if (info->title) {
- tag_len = strlen (info->title);
+ tag_len = strlen(info->title);
cnv_len = 0;
- formatContext->title = mmfile_string_convert ((const char*)info->title,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
+ formatContext->title = mmfile_string_convert((const char *)info->title,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
if (formatContext->title == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->title = mmfile_strdup (info->title);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->title = mmfile_strdup(info->title);
}
}
if (info->copyright) {
- tag_len = strlen (info->copyright);
+ tag_len = strlen(info->copyright);
cnv_len = 0;
- formatContext->copyright = mmfile_string_convert ((const char*)info->copyright,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
+ formatContext->copyright = mmfile_string_convert((const char *)info->copyright,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
if (formatContext->copyright == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->copyright = mmfile_strdup (info->copyright);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->copyright = mmfile_strdup(info->copyright);
}
}
if (info->comment) {
- tag_len = strlen (info->comment);
+ tag_len = strlen(info->comment);
cnv_len = 0;
- formatContext->comment = mmfile_string_convert ((const char*)info->comment,
- tag_len,
- "UTF-8",
- locale,
- NULL,
- (unsigned int*)&cnv_len);
+ formatContext->comment = mmfile_string_convert((const char *)info->comment,
+ tag_len,
+ "UTF-8",
+ locale,
+ NULL,
+ (unsigned int *)&cnv_len);
if (formatContext->comment == NULL) {
- debug_warning ("failed to UTF8 convert.\n");
- formatContext->comment = mmfile_strdup (info->comment);
+ debug_warning("failed to UTF8 convert.\n");
+ formatContext->comment = mmfile_strdup(info->comment);
}
}
#ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_contents (formatContext);
+ mmfile_format_print_contents(formatContext);
#endif
- mmfile_format_free_midi_infomation (info);
+ mmfile_format_free_midi_infomation(info);
return MMFILE_FORMAT_SUCCESS;
exception:
- mmfile_format_free_midi_infomation (info);
+ mmfile_format_free_midi_infomation(info);
return ret;
}
EXPORT_API
-int mmfile_format_read_frame_mid (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_mid(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
- debug_error ("error: mmfile_format_read_frame_midi, no handling\n");
+ debug_error("error: mmfile_format_read_frame_midi, no handling\n");
- return MMFILE_FORMAT_FAIL;
+ return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_close_mid (MMFileFormatContext *formatContext)
+int mmfile_format_close_mid(MMFileFormatContext *formatContext)
{
- if (NULL == formatContext ) {
- debug_error ("error: invalid params\n");
+ if (NULL == formatContext) {
+ debug_error("error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
- if(formatContext->streams[MMFILE_AUDIO_STREAM]) {
+ if (formatContext->streams[MMFILE_AUDIO_STREAM]) {
mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
}
return MMFILE_FORMAT_SUCCESS;
}
-static char * _lc_strdup (const char *str, unsigned int size)
+static char *_lc_strdup(const char *str, unsigned int size)
{
char *t = NULL;
- t = mmfile_malloc (size+1);
+ t = mmfile_malloc(size + 1);
if (t) {
- memset (t, 0x00, size+1);
- memcpy (t, str, size);
+ memset(t, 0x00, size + 1);
+ memcpy(t, str, size);
}
return t;
}
MIDI_INFO_SIMPLE *
-mmfile_format_get_midi_infomation (char* szFileName)
+mmfile_format_get_midi_infomation(char *szFileName)
{
- int duration = -1;
+ /*int duration = -1;*/
MIDI_INFO_SIMPLE *info = NULL;
- info = mmfile_malloc (sizeof (MIDI_INFO_SIMPLE));
+ info = mmfile_malloc(sizeof(MIDI_INFO_SIMPLE));
if (!info)
return NULL;
/*get infomation*/
- duration = __AvGetMidiDuration (szFileName, info);
+ /*duration = */__AvGetMidiDuration(szFileName, info);
return info;
}
void
-mmfile_format_free_midi_infomation (MIDI_INFO_SIMPLE *info)
+mmfile_format_free_midi_infomation(MIDI_INFO_SIMPLE *info)
{
if (info) {
- if (info->title) mmfile_free (info->title);
- if (info->copyright) mmfile_free (info->copyright);
- if (info->comment) mmfile_free (info->comment);
- mmfile_free (info);
+ if (info->title) mmfile_free(info->title);
+ if (info->copyright) mmfile_free(info->copyright);
+ if (info->comment) mmfile_free(info->comment);
+ mmfile_free(info);
}
}
* Return
* >= 0 : FileID, < 0 : Error code
****************************************************************************/
-static int
-__AvGetMidiDuration(char* szFileName, MIDI_INFO_SIMPLE *info)
+static int
+__AvGetMidiDuration(char *szFileName, MIDI_INFO_SIMPLE *info)
{
- int xmfheaderSkip=0;
- MMFileIOHandle * hFile = NULL;
- UINT8 * pbFile= NULL;
- UINT8 * pIMYbuf= NULL;
+ int xmfheaderSkip = 0;
+ MMFileIOHandle *hFile = NULL;
+ UINT8 *pbFile = NULL;
+ UINT8 *pIMYbuf = NULL;
SINT32 dFileSize;
int sdCurrentTime = 0;
- // void* pvExtArgs = "mid";
- int readed =0;
+ /* void* pvExtArgs = "mid"; */
+ int readed = 0;
int ret;
int codecType = AV_DEC_AUDIO_MIDI;
int is_xmf = 0;
- if ( szFileName == NULL || info == NULL)
+ if (szFileName == NULL || info == NULL)
return -1;
- // debug_msg ("URI: %s\n", szFileName);
+ /* debug_msg("URI: %s\n", szFileName); */
/*open*/
- ret = mmfile_open (&hFile, szFileName, MMFILE_RDONLY);
+ ret = mmfile_open(&hFile, szFileName, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error ( "open failed.\n");
+ debug_error("open failed.\n");
return -1;
}
/*get file size*/
- mmfile_seek (hFile, 0L, MMFILE_SEEK_END);
- dFileSize = mmfile_tell (hFile);
- mmfile_seek (hFile, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(hFile, 0L, MMFILE_SEEK_END);
+ dFileSize = mmfile_tell(hFile);
+ mmfile_seek(hFile, 0L, MMFILE_SEEK_SET);
if (dFileSize <= 0) {
- debug_error ("failed to get file size.\n");
+ debug_error("failed to get file size.\n");
goto _RELEASE_RESOURCE;
}
/*alloc read buffer*/
- pbFile = (UINT8 *) mmfile_malloc (sizeof(UINT8) * (dFileSize + 1));
+ pbFile = (UINT8 *) mmfile_malloc(sizeof(UINT8) * (dFileSize + 1));
if (!pbFile) {
- debug_error ( "memory allocation failed.\n");
+ debug_error("memory allocation failed.\n");
goto _RELEASE_RESOURCE;
}
/*read data*/
- if ((readed = mmfile_read (hFile, pbFile, dFileSize) ) != dFileSize) {
- debug_error ( "read error. size = %d\n", readed);
+ if ((readed = mmfile_read(hFile, pbFile, dFileSize)) != dFileSize) {
+ debug_error("read error. size = %d\n", readed);
goto _RELEASE_RESOURCE;
}
/*init global workspace*/
- if(__AvMidFile_Initialize())
+ if (__AvMidFile_Initialize())
goto _RELEASE_RESOURCE;
/*check format*/
- if (!(memcmp (pbFile, MMFILE_XMF_100, 8)) ||
- !(memcmp (pbFile, MMFILE_XMF_101, 8)) ||
- !(memcmp (pbFile, MMFILE_MXMF_200, 8))) {
+ if (!(memcmp(pbFile, MMFILE_XMF_100, 8)) ||
+ !(memcmp(pbFile, MMFILE_XMF_101, 8)) ||
+ !(memcmp(pbFile, MMFILE_MXMF_200, 8))) {
is_xmf = 1;
codecType = AV_DEC_AUDIO_XMF;
- } else if (!(memcmp (pbFile, MMFILE_RMF, 4))) {
+ } else if (!(memcmp(pbFile, MMFILE_RMF, 4))) {
is_xmf = 0;
codecType = AV_DEC_AUDIO_RMF;
} else {
} else {
/*get duration. XMF/MIDI*/
- if(codecType == AV_DEC_AUDIO_XMF) {
+ if (codecType == AV_DEC_AUDIO_XMF) {
xmfheaderSkip = __AvParseSkipXmf2Mid(pbFile, dFileSize);
- if(xmfheaderSkip == -1)
+ if (xmfheaderSkip == -1)
goto _RELEASE_RESOURCE;
- sdCurrentTime = __AvCheckSizeOfMidFile(pbFile+xmfheaderSkip, dFileSize);
+ sdCurrentTime = __AvCheckSizeOfMidFile(pbFile + xmfheaderSkip, dFileSize);
} else {
sdCurrentTime = __AvCheckSizeOfMidFile(pbFile, dFileSize);
}
- if(sdCurrentTime < 0) {
- debug_error ("__AvGetMidiDuration: sdResult's error Code!(%d)\n", sdCurrentTime);
+ if (sdCurrentTime < 0) {
+ debug_error("__AvGetMidiDuration: sdResult's error Code!(%d)\n", sdCurrentTime);
goto _RELEASE_RESOURCE;
}
- if(sdCurrentTime > 0)
+ if (sdCurrentTime > 0)
sdCurrentTime /= 1000;
info->duration = sdCurrentTime;
info->track_num = gPi->dNumOfTracks;
info->is_xmf = is_xmf;
- info->title = _lc_strdup ((const char *)gPi->pbTitle, gPi->dSizeTitle);
- info->copyright = _lc_strdup ((const char *)gPi->pbCopyright, gPi->dSizeCopyright);
- info->comment = _lc_strdup ((const char *)gPi->pbText, gPi->dSizeText);
+ info->title = _lc_strdup((const char *)gPi->pbTitle, gPi->dSizeTitle);
+ info->copyright = _lc_strdup((const char *)gPi->pbCopyright, gPi->dSizeCopyright);
+ info->comment = _lc_strdup((const char *)gPi->pbText, gPi->dSizeText);
}
_RELEASE_RESOURCE:
/*resource release*/
- __AvMidFile_Deinitialize ();
- mmfile_close (hFile);
- mmfile_free (pbFile);
- mmfile_free (pIMYbuf);
+ __AvMidFile_Deinitialize();
+ mmfile_close(hFile);
+ mmfile_free(pbFile);
+ mmfile_free(pIMYbuf);
return sdCurrentTime;
}
static SINT32
__AvMidFile_Initialize(void)
{
- gpMidInfo = mmfile_malloc (sizeof (MIDGLOBAL));
+ gpMidInfo = mmfile_malloc(sizeof(MIDGLOBAL));
if (!gpMidInfo)
return (AvSMW_ERROR);
- memset (gpMidInfo, 0x00, sizeof (MIDGLOBAL));
+ memset(gpMidInfo, 0x00, sizeof(MIDGLOBAL));
gpMidInfo->sdSeqID = -1; /* Sequence ID */
gpMidInfo->sdFileID = -1; /* File ID */
static void
__AvMidFile_Deinitialize(void)
{
- mmfile_free (gpMidInfo);
+ mmfile_free(gpMidInfo);
}
* Return:
* none
****************************************************************************/
-static void
+static void
__AvMidInitializeOrderList(PMIDINFO pI)
{
int ix2;
- for (ix2 = 1; ix2 <= MAX_SMF_TRACKS + 1; ix2++)
- {
+ for (ix2 = 1; ix2 <= MAX_SMF_TRACKS + 1; ix2++) {
pI->OrderList[ix2].pPrev = &pI->OrderList[ix2 - 1];
pI->OrderList[ix2].pNext = &pI->OrderList[ix2 + 1];
pI->OrderList[ix2].dTrack = 0xFF;
* Return:
* none
****************************************************************************/
-static void
+static void
__AvMidSortOrderList(PMIDINFO pI)
{
PORDERLIST pSlot;
pSlot->dTicks = ((UINT32)pI->TrackInfo[pSlot->dTrack].sdTicks << 5) + pSlot->dTrack;
pTerget = pSlot->pNext;
- while (pTerget != pI->pDoneOrderList)
- {
+ while (pTerget != pI->pDoneOrderList) {
if (pSlot->dTicks <= pTerget->dTicks) break;
pTerget = pTerget->pNext;
}
pTerget = pI->pDoneOrderList->pNext;
if (pTerget == pI->pBottomOrderList) return;
-
+
pI->pDoneOrderList->pNext = pTerget->pNext;
(pTerget->pNext)->pPrev = pI->pDoneOrderList;
pTerget->pNext = (pI->pTopOrderList)->pNext;
((pI->pTopOrderList)->pNext)->pPrev = pTerget;
(pI->pTopOrderList)->pNext = pTerget;
-
+
__AvMidSortOrderList(pI);
}
* Return:
* none
****************************************************************************/
-static void
+static void
__AvMidRemoveFromOrderList(PMIDINFO pI)
{
PORDERLIST pSlot;
pSlot = (pI->pTopOrderList)->pNext;
(pSlot->pPrev)->pNext = pSlot->pNext;
(pSlot->pNext)->pPrev = pSlot->pPrev;
-
+
pTerget = pI->pBottomOrderList;
(pTerget->pPrev)->pNext = pSlot;
pSlot->pPrev = pTerget->pPrev;
pMt = &(pI->TrackInfo[dTrack]);
dTime = 0;
- do
- {
- if (pMt->dOffset >= pMt->dSize)
- {
+ do {
+ if (pMt->dOffset >= pMt->dSize) {
pI->dEndFlag &= ~(1L << dTrack);
return (-1);
}
dTemp = (UINT32)pMt->pbBase[pMt->dOffset++];
dTime = (dTime << 7) + (dTemp & 0x7f);
} while (dTemp >= 0x80);
- //debug_msg("dTime is %d\n", dTime);
+ /*debug_msg("dTime is %d\n", dTime); */
pMt->sdTicks += dTime;
return (0);
SINT32 dTime;
PTRACKINFO pMt;
- if (pI->dNumOfTracks == 1)
- {
+ if (pI->dNumOfTracks == 1) {
/* Single track */
- if (((pI->dEndFlag >> dTrack) & 0x01) == 0)
- {
+ if (((pI->dEndFlag >> dTrack) & 0x01) == 0) {
return (-1);
}
pMt = &(pI->TrackInfo[dTrack]);
dTime = 0;
- do
- {
- if (pMt->dOffset >= pMt->dSize)
- {
+ do {
+ if (pMt->dOffset >= pMt->dSize) {
pI->dEndFlag &= ~(1L << dTrack);
return (-1);
}
} while (dTemp >= 0x80);
pMt->sdTicks += dTime;
- }
- else
- {
+ } else {
/* Multi track */
- if (((pI->dEndFlag >> dTrack) & 0x01) == 0)
- {
+ if (((pI->dEndFlag >> dTrack) & 0x01) == 0) {
__AvMidRemoveFromOrderList(pI);
return (-1);
}
pMt = &(pI->TrackInfo[dTrack]);
dTime = 0;
- do
- {
- if (pMt->dOffset >= pMt->dSize)
- {
+ do {
+ if (pMt->dOffset >= pMt->dSize) {
pI->dEndFlag &= ~(1L << dTrack);
__AvMidRemoveFromOrderList(pI);
return (-1);
static void
__AvMidResetTimeInfo(PMIDINFO pI)
{
- SINT32 sdTrack;
+ UINT32 sdTrack;
PTRACKINFO pMt;
pI->dEndFlag = 0;
- for (sdTrack = 0; sdTrack < (UINT32)pI->dNumOfTracks; sdTrack++)
- {
+ for (sdTrack = 0; sdTrack < (UINT32)pI->dNumOfTracks; sdTrack++) {
pMt = &(pI->TrackInfo[sdTrack]);
pMt->dSmfCmd = 0;
pMt->sdTicks = 0;
if (pMt->dSize > 0) pI->dEndFlag |= (1L << sdTrack);
}
-
+
__AvMidInitializeOrderList(pI);
- if((UINT32)pI->dNumOfTracks > MAX_SMF_TRACKS)
- {
- debug_error ("__AvMidResetTimeInfo: Num of tracks is over MAX track number. !!\n");
+ if ((UINT32)pI->dNumOfTracks > MAX_SMF_TRACKS) {
+ debug_error("__AvMidResetTimeInfo: Num of tracks is over MAX track number. !!\n");
return;
}
- for (sdTrack = 0; sdTrack < (UINT32)pI->dNumOfTracks; sdTrack++)
- {
+ for (sdTrack = 0; sdTrack < (UINT32)pI->dNumOfTracks; sdTrack++) {
__AvMidGetTrackTime(pI, (UINT32)sdTrack);
pMt = &(pI->TrackInfo[sdTrack]);
- __AvMidInsertOrderList(pI, (UINT32)sdTrack, pMt->sdTicks);
+ __AvMidInsertOrderList(pI, (UINT32)sdTrack, pMt->sdTicks);
}
}
UINT32 dCmd;
UINT32 dCmd2;
UINT32 dSize;
-
+
UINT32 dTemp;
UINT32 dTime;
- SINT32 sdTotalTicks;
+ UINT32 sdTotalTicks;
SINT32 sdCurrentTime;
SINT32 sdDelta;
PMIDCHINFO pCh;
static UINT32 dBank[16];
static UINT32 dCurrBank[16];
-
+
SINT32 sdNonConductorTime;
SINT32 sdNonConductorTicks;
UINT32 dConductorNote;
pI->dStart = 0;
pI->dSetupBar = 0;
pI->dVibNoteVoice = 0;
-
- for (dCh = 0; dCh < NUM_OF_MAPS; dCh++)
- {
- for (dTemp = 0; dTemp < 128; dTemp++)
- {
+
+ for (dCh = 0; dCh < NUM_OF_MAPS; dCh++) {
+ for (dTemp = 0; dTemp < 128; dTemp++) {
pI->bVoiceMap[dCh][dTemp] = 0;
}
}
pI->bVoiceMap[MELODY_MAP][0] = 1; /* GM Default Piano */
- for (dCh = 0; dCh < 16; dCh++)
- {
+ for (dCh = 0; dCh < 16; dCh++) {
dBank[dCh] = 0;
dCurrBank[dCh] = 0;
pCh = &pI->ChInfo[dCh];
if (pI->dSmfFormat != 0) dSetup |= 0x20;
- while (pI->dEndFlag != 0)
- {
- if ((pI->dEndFlag == 1) && (sdNonConductorTime == 0x7FFFFFFF))
- {
+ while (pI->dEndFlag != 0) {
+ if ((pI->dEndFlag == 1) && (sdNonConductorTime == 0x7FFFFFFF)) {
sdNonConductorTime = sdCurrentTime;
sdNonConductorTicks = sdTotalTicks;
dConductorNote |= 2;
}
-
- if (pI->dNumOfTracks == 1)
- {
+
+ if (pI->dNumOfTracks == 1) {
sdTr = 0;
- }
- else
- {
+ } else {
sdTr = __AvMidGetLeastTimeTrack(pI);
if (sdTr < 0) break;
}
pMt = &(pI->TrackInfo[sdTr]);
-
+
dTime = pMt->sdTicks - sdTotalTicks;
sdCurrentTime += dTime * sdDelta;
sdTotalTicks = pMt->sdTicks;
- if ((sdCurrentTime < 0) || (sdTotalTicks > 0x07FFFFFFL))
- {
+ if ((sdCurrentTime < 0) || (sdTotalTicks > 0x07FFFFFFL)) {
return (AvSMW_ERROR_LONG_LENGTH);
}
dCmd = (UINT32)pMt->pbBase[pMt->dOffset++];
- if (dCmd < 0xf0)
- {
+ if (dCmd < 0xf0) {
/*--- MidiMsg ---*/
- if (dCmd < 0x80)
- {
+ if (dCmd < 0x80) {
dCmd = pMt->dSmfCmd;
if (dCmd < 0x80) return (AvSMW_ERROR_SMF_CMD);
pMt->dOffset--;
} else {
pMt->dSmfCmd = dCmd;
}
-
+
dCh = dCmd & 0x0f;
-
- switch (dCmd & 0xf0)
- {
- case 0x90: /* NoteOn */
- /* Conductor Track Note Check */
- if (sdTr == 0) dConductorNote |= 1;
- switch (dCurrBank[dCh] >> 8)
- {
- case 0x79:
- /* Melody */
- break;
- case 0x78:
- /* Drum */
- pI->bVoiceMap[DRUM_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
+ switch (dCmd & 0xf0) {
+ case 0x90: /* NoteOn */
+ /* Conductor Track Note Check */
+ if (sdTr == 0) dConductorNote |= 1;
+ switch (dCurrBank[dCh] >> 8) {
+ case 0x79:
+ /* Melody */
+ break;
+
+ case 0x78:
+ /* Drum */
+ pI->bVoiceMap[DRUM_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
+ break;
+
+ default:
+ if (dCh == 9) {
+ /* Unknown: default GM Drum */
+ pI->bVoiceMap[DRUM_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
+ }
+ }
+ pMt->dOffset += 2;
break;
- default:
- if (dCh == 9)
- {
- /* Unknown: default GM Drum */
- pI->bVoiceMap[DRUM_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
- }
- }
- pMt->dOffset += 2;
- break;
-
- case 0xC0: /* Program change */
- switch (dBank[dCh] >> 8)
- {
- case 0x79:
- if (dBank[dCh] != 0x7906)
- {
- /* Melody */
- pI->bVoiceMap[MELODY_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
- }
- else
- {
- /* Vibration Note */
- pI->dVibNoteVoice = 1;
+ case 0xC0: /* Program change */
+ switch (dBank[dCh] >> 8) {
+ case 0x79:
+ if (dBank[dCh] != 0x7906) {
+ /* Melody */
+ pI->bVoiceMap[MELODY_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
+ } else {
+ /* Vibration Note */
+ pI->dVibNoteVoice = 1;
+ }
+ break;
+
+ case 0x78:
+ /* Drum */
+ break;
+
+ default:
+ /* default GM Melody */
+ if (dCh != 9) {
+ pI->bVoiceMap[MELODY_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
+ }
}
+
+ dCurrBank[dCh] = dBank[dCh];
+ pMt->dOffset++;
break;
- case 0x78:
- /* Drum */
+ case 0xD0: /* Channel pressure */
+ pMt->dOffset++;
break;
- default:
- /* default GM Melody */
- if (dCh != 9)
- {
- pI->bVoiceMap[MELODY_MAP][pMt->pbBase[pMt->dOffset] & 0x7F] = 1;
+ case 0xB0: /* Control Change */
+ switch (pMt->pbBase[pMt->dOffset]) {
+ case 0x00: /* Bank select(MSB) */
+ dBank[dCh] = (dBank[dCh] & 0x00FF) | (pMt->pbBase[pMt->dOffset + 1] << 8);
+ break;
+
+ case 0x20: /* Bank select (LSB) */
+ dBank[dCh] = (dBank[dCh] & 0xFF00) | pMt->pbBase[pMt->dOffset + 1];
+ break;
+ default:
+ break;
}
- }
-
- dCurrBank[dCh] = dBank[dCh];
- pMt->dOffset++;
- break;
-
- case 0xD0: /* Channel pressure */
- pMt->dOffset++;
- break;
-
- case 0xB0: /* Control Change */
- switch (pMt->pbBase[pMt->dOffset])
- {
- case 0x00: /* Bank select(MSB) */
- dBank[dCh] = (dBank[dCh] & 0x00FF) | (pMt->pbBase[pMt->dOffset + 1] << 8);
+ pMt->dOffset += 2;
break;
- case 0x20: /* Bank select (LSB) */
- dBank[dCh] = (dBank[dCh] & 0xFF00) | pMt->pbBase[pMt->dOffset + 1];
- break;
- default :
+ default:
+ pMt->dOffset += 2;
break;
- }
- pMt->dOffset += 2;
- break;
-
- default:
- pMt->dOffset += 2;
}
- }
- else
- {
- switch (dCmd)
- {
- case 0xF0: /* SysEx */
- case 0xF7: /* SysEx */
- pMt->dSmfCmd = 0;
- dSize = 0;
- do
- {
- dTemp = (UINT32)pMt->pbBase[pMt->dOffset++];
- dSize = (dSize << 7) + (dTemp & 0x7f);
- } while (dTemp >= 0x80);
-
- if ((dSize == 5) &&
- (pMt->pbBase[pMt->dOffset] == 0x7e) &&
- (pMt->pbBase[pMt->dOffset + 1] == 0x7f) &&
- (pMt->pbBase[pMt->dOffset + 2] == 0x09) &&
- (pMt->pbBase[pMt->dOffset + 3] == 0x01))
- {
- /* System On */
- if (sdTotalTicks == 0)
- {
- dSetup |= 0x04;
- }
- }
- else
- {
- if (pI->dSetupBar == 0)
- {
- if ((dSize == 22) &&
- (pMt->pbBase[pMt->dOffset] == 0x43) &&
- (pMt->pbBase[pMt->dOffset + 1] == 0x79) &&
- (pMt->pbBase[pMt->dOffset + 2] == 0x06) &&
- (pMt->pbBase[pMt->dOffset + 3] == 0x7C)&&
- (pMt->pbBase[pMt->dOffset + 4] == 0x02))
- {
- /* Channel status */
- for (dCh = 0; dCh < 16; dCh++)
- {
- pCh = &pI->ChInfo[dCh];
- dTemp = pMt->pbBase[pMt->dOffset + 5 + dCh];
- pCh->dKeyCon = (dTemp >> 2) & 0x03;
- pCh->dVibSync = (dTemp >> 1) & 0x01;
- pCh->dLedSync = dTemp & 0x01;
+ } else {
+ switch (dCmd) {
+ case 0xF0: /* SysEx */
+ case 0xF7: /* SysEx */
+ pMt->dSmfCmd = 0;
+ dSize = 0;
+ do {
+ dTemp = (UINT32)pMt->pbBase[pMt->dOffset++];
+ dSize = (dSize << 7) + (dTemp & 0x7f);
+ } while (dTemp >= 0x80);
+
+ if ((dSize == 5) &&
+ (pMt->pbBase[pMt->dOffset] == 0x7e) &&
+ (pMt->pbBase[pMt->dOffset + 1] == 0x7f) &&
+ (pMt->pbBase[pMt->dOffset + 2] == 0x09) &&
+ (pMt->pbBase[pMt->dOffset + 3] == 0x01)) {
+ /* System On */
+ if (sdTotalTicks == 0) {
+ dSetup |= 0x04;
+ }
+ } else {
+ if (pI->dSetupBar == 0) {
+ if ((dSize == 22) &&
+ (pMt->pbBase[pMt->dOffset] == 0x43) &&
+ (pMt->pbBase[pMt->dOffset + 1] == 0x79) &&
+ (pMt->pbBase[pMt->dOffset + 2] == 0x06) &&
+ (pMt->pbBase[pMt->dOffset + 3] == 0x7C) &&
+ (pMt->pbBase[pMt->dOffset + 4] == 0x02)) {
+ /* Channel status */
+ for (dCh = 0; dCh < 16; dCh++) {
+ pCh = &pI->ChInfo[dCh];
+ dTemp = pMt->pbBase[pMt->dOffset + 5 + dCh];
+ pCh->dKeyCon = (dTemp >> 2) & 0x03;
+ pCh->dVibSync = (dTemp >> 1) & 0x01;
+ pCh->dLedSync = dTemp & 0x01;
+ }
}
}
}
- }
-
- pMt->dOffset += dSize;
- break;
-
- case 0xF1: /* System Msg */
- case 0xF3: /* System Msg */
- pMt->dOffset++;
- break;
-
- case 0xF2: /* System Msg */
- pMt->dOffset += 2;
- break;
-
- case 0xFF: /* Meta */
- dCmd2 = (UINT32)pMt->pbBase[pMt->dOffset++]; /* Meta Command */
- dSize = 0; /* Size */
- do
- {
- dTemp = (UINT32)pMt->pbBase[pMt->dOffset++];
- dSize = (dSize << 7) + (dTemp & 0x7f);
- } while (dTemp >= 0x80);
-
- switch (dCmd2)
- {
- case 0x01: /* Text */
- if (pI->pbText == NULL)
- {
- pI->pbText = &pMt->pbBase[pMt->dOffset];
- pI->dSizeText = dSize;
- }
- break;
- case 0x02: /* Copyright */
- if (pI->pbCopyright == NULL)
- {
- pI->pbCopyright = &pMt->pbBase[pMt->dOffset];
- pI->dSizeCopyright = dSize;
- }
+ pMt->dOffset += dSize;
break;
- case 0x06: /* Title */
- if (pI->pbTitle == NULL)
- {
- pI->pbTitle = &pMt->pbBase[pMt->dOffset];
- pI->dSizeTitle = dSize;
- }
+ case 0xF1: /* System Msg */
+ case 0xF3: /* System Msg */
+ pMt->dOffset++;
break;
- case 0x2f: /* End */
- pI->dEndFlag &= ~(1L << sdTr);
- break;
-
- case 0x51: /* Set Tempo */
- switch (dSize)
- {
- case 3:
- case 4:
- dTime = ((UINT32)pMt->pbBase[pMt->dOffset] << 16) +
- ((UINT32)pMt->pbBase[pMt->dOffset + 1] << 8) +
- (UINT32)pMt->pbBase[pMt->dOffset + 2];
- if ((sdTotalTicks == 0) && (dTime == 250000)) dSetup |= 0x02;
- if (sdTotalTicks == (UINT32)pI->dTimeResolution) dSetup |= 0x08;
-
- /*<== I Think that Below Code is Trash!! and Erase it! (Actually I Don Know ^^)
- dTime = (dTime << 7) / 125; */
-
- sdDelta = (UINT32)(dTime / pI->dTimeResolution);
- }
+ case 0xF2: /* System Msg */
+ pMt->dOffset += 2;
break;
- case 0x58: /* Set TimeSignature */
- if ((sdTotalTicks == 0) &&
- (pMt->pbBase[pMt->dOffset] == 1) &&
- (pMt->pbBase[pMt->dOffset + 1] == 2)) dSetup |= 0x01;
+ case 0xFF: /* Meta */
+ dCmd2 = (UINT32)pMt->pbBase[pMt->dOffset++]; /* Meta Command */
+ dSize = 0; /* Size */
+ do {
+ dTemp = (UINT32)pMt->pbBase[pMt->dOffset++];
+ dSize = (dSize << 7) + (dTemp & 0x7f);
+ } while (dTemp >= 0x80);
+
+ switch (dCmd2) {
+ case 0x01: /* Text */
+ if (pI->pbText == NULL) {
+ pI->pbText = &pMt->pbBase[pMt->dOffset];
+ pI->dSizeText = dSize;
+ }
+ break;
+
+ case 0x02: /* Copyright */
+ if (pI->pbCopyright == NULL) {
+ pI->pbCopyright = &pMt->pbBase[pMt->dOffset];
+ pI->dSizeCopyright = dSize;
+ }
+ break;
+
+ case 0x06: /* Title */
+ if (pI->pbTitle == NULL) {
+ pI->pbTitle = &pMt->pbBase[pMt->dOffset];
+ pI->dSizeTitle = dSize;
+ }
+ break;
+
+ case 0x2f: /* End */
+ pI->dEndFlag &= ~(1L << sdTr);
+ break;
+
+ case 0x51: /* Set Tempo */
+ switch (dSize) {
+ case 3:
+ case 4:
+ dTime = ((UINT32)pMt->pbBase[pMt->dOffset] << 16) +
+ ((UINT32)pMt->pbBase[pMt->dOffset + 1] << 8) +
+ (UINT32)pMt->pbBase[pMt->dOffset + 2];
+ if ((sdTotalTicks == 0) && (dTime == 250000)) dSetup |= 0x02;
+ if (sdTotalTicks == (UINT32)pI->dTimeResolution) dSetup |= 0x08;
+
+ /*<== I Think that Below Code is Trash!! and Erase it! (Actually I Don Know ^^)
+ dTime = (dTime << 7) / 125; */
+
+ sdDelta = (UINT32)(dTime / pI->dTimeResolution);
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ case 0x58: /* Set TimeSignature */
+ if ((sdTotalTicks == 0) &&
+ (pMt->pbBase[pMt->dOffset] == 1) &&
+ (pMt->pbBase[pMt->dOffset + 1] == 2)) dSetup |= 0x01;
+ break;
+ default:
+ break;
+ }
+ pMt->dOffset += dSize;
break;
- default :
+ default:
break;
- }
- pMt->dOffset += dSize;
- break;
- default :
- break;
}
}
- if((UINT32)sdTr >= MAX_SMF_TRACKS)
- {
- debug_error ("__AvGetSizeOfFileInfo: Num of tracks is over MAX track number. !!\n");
+ if ((UINT32)sdTr >= MAX_SMF_TRACKS) {
+ debug_error("__AvGetSizeOfFileInfo: Num of tracks is over MAX track number. !!\n");
return AvSMW_ERROR_SMF_CMD;
}
__AvMidUpdateTrackTime(pI, (UINT32)sdTr);
- if (dSetup == 0x0F)
- {
+ if (dSetup == 0x0F) {
dSetup |= 0x10;
sdCurrentTime = 0;
pI->dSetupBar = 1;
}
}
- if ((dConductorNote != 2) || (pI->dSmfFormat == 0))
- {
+ if ((dConductorNote != 2) || (pI->dSmfFormat == 0)) {
pI->sdTotalTicks = sdTotalTicks;
pI->sdDataEndTime = sdCurrentTime;
- }
- else
- {
+ } else {
pI->sdTotalTicks = sdNonConductorTicks;
pI->sdDataEndTime = sdNonConductorTime;
}
-
- if (pI->dSetupBar == 0)
- {
- for (dCh = 0; dCh < 16; dCh++)
- {
+
+ if (pI->dSetupBar == 0) {
+ for (dCh = 0; dCh < 16; dCh++) {
pCh = &pI->ChInfo[dCh];
pCh->dKeyCon = 0;
pCh->dVibSync = 0;
}
if ((pI->sdDataEndTime >> 10) <= MINIMUM_LENGTH) return (AvSMW_ERROR_SHORT_LENGTH);
- // debug_msg("__AvGetSizeOfFileInfo/Done\n");
+ /* debug_msg("__AvGetSizeOfFileInfo/Done\n"); */
return pI->sdDataEndTime;
}
* 0 : NoError, < 0 : Error
****************************************************************************/
static SINT32
-__AvCheckSizeOfMidFile(UINT8* src_fp, UINT32 dFsize)
+__AvCheckSizeOfMidFile(UINT8 *src_fp, UINT32 dFsize)
{
UINT32 dTemp;
UINT32 dSize;
UINT32 dNumOfTracks;
UINT32 i;
UINT8 *fp = src_fp;
- // debug_msg ("input param: %p, %d\n", fp , dFsize);
- while (dFsize >= 22)
- {
+ /* debug_msg("input param: %p, %d\n", fp, dFsize); */
+ while (dFsize >= 22) {
dTemp = ((UINT32)fp[0] << 24) + ((UINT32)fp[1] << 16) +
((UINT32)fp[2] << 8) + (UINT32)fp[3];
if (dTemp == 0x4D546864) break; /* 'MThd' */
- fp ++;
- dFsize --;
+ fp++;
+ dFsize--;
}
- // debug_msg("__AvCheckSizeOfMidFile(): MThd Position is dFsize(%d)\n", dFsize);
+ /* debug_msg("__AvCheckSizeOfMidFile(): MThd Position is dFsize(%d)\n", dFsize); */
- if (dFsize < 22)
- {
- debug_error ("__AvCheckSizeOfMidFile Error / Too small size\n");
+ if (dFsize < 22) {
+ debug_error("__AvCheckSizeOfMidFile Error / Too small size\n");
return (AvSMW_ERROR_FILE);
}
/*--- Check size ----------------------------------------------------*/
dTemp = ((UINT32)fp[0] << 24) + ((UINT32)fp[1] << 16) +
((UINT32)fp[2] << 8) + (UINT32)fp[3];
-
- if (dTemp != 6)
- {
- debug_error ("__AvCheckSizeOfMidFile Error / Size != 6\n");
+
+ if (dTemp != 6) {
+ debug_error("__AvCheckSizeOfMidFile Error / Size != 6\n");
return (AvSMW_ERROR_CHUNK_SIZE);
}
-
+
fp += 4;
dFsize -= 4;
if (gpMidInfo->DataInfo[1].dValid == 1) return (AvSMW_ERROR);
- pI = &gpMidInfo->DataInfo[1];
-
+ pI = &gpMidInfo->DataInfo[1];
+
/**
* set global val
*/
/*--- Check format -------------------------------------------------*/
dFormat = ((UINT32)fp[0] << 8) + (UINT32)fp[1];
- if (dFormat > 1)
- {
- debug_error ("__AvCheckSizeOfMidFile Error/ Not Format 0 or 1\n");
+ if (dFormat > 1) {
+ debug_error("__AvCheckSizeOfMidFile Error/ Not Format 0 or 1\n");
return (AvSMW_ERROR_SMF_FORMAT);
}
-
+
/*--- Check number of tracks ---------------------------------------*/
dNumOfTracks = (SINT32)((UINT32)fp[2] << 8) + (UINT32)fp[3];
- if (dNumOfTracks == 0)
- {
- debug_error ("__AvCheckSizeOfMidFile Error/ Number of Tracks = 0\n");
+ if (dNumOfTracks == 0) {
+ debug_error("__AvCheckSizeOfMidFile Error/ Number of Tracks = 0\n");
return (AvSMW_ERROR_SMF_TRACKNUM);
}
- if ((dFormat == 0) && (dNumOfTracks != 1))
- {
- debug_error ("__AvCheckSizeOfMidFile Error/ Number of Tracks > 1\n");
+ if ((dFormat == 0) && (dNumOfTracks != 1)) {
+ debug_error("__AvCheckSizeOfMidFile Error/ Number of Tracks > 1\n");
return (AvSMW_ERROR_SMF_TRACKNUM);
}
-
+
if (dNumOfTracks > MAX_SMF_TRACKS) dNumOfTracks = MAX_SMF_TRACKS;
pI->dNumOfTracks = (UINT8)dNumOfTracks;
/*--- Check Time unit --------------------------------------------*/
dTemp = ((UINT32)fp[4] << 8) + (UINT32)fp[5];
pI->dTimeResolution = dTemp & 0x7fff;
- if (((dTemp & 0x8000) != 0) || (pI->dTimeResolution == 0))
- {
- debug_error ("__AvCheckSizeOfMidFile Error/ Unknown TimeUnit\n");
+ if (((dTemp & 0x8000) != 0) || (pI->dTimeResolution == 0)) {
+ debug_error("__AvCheckSizeOfMidFile Error/ Unknown TimeUnit\n");
return (AvSMW_ERROR_SMF_TIMEUNIT);
}
fp += 6;
dFsize -= 6;
-
- for (i = 0; i < dNumOfTracks; i++)
- {
+
+ for (i = 0; i < dNumOfTracks; i++) {
/*--- Check chunk name --------------------------------------------*/
- while (dFsize >= 8)
- {
+ while (dFsize >= 8) {
dTemp = ((UINT32)fp[0] << 24) + ((UINT32)fp[1] << 16) +
((UINT32)fp[2] << 8) + (UINT32)fp[3];
if (dTemp == 0x4D54726B) break; /* 'MTrk' */
- fp ++;
- dFsize --;
+ fp++;
+ dFsize--;
}
- if (dFsize < 8)
- {
- debug_error ("__AvCheckSizeOfMidFile Error/ Bad size\n");
+ if (dFsize < 8) {
+ debug_error("__AvCheckSizeOfMidFile Error/ Bad size\n");
return (AvSMW_ERROR_CHUNK_SIZE);
}
dSize = ((UINT32)fp[4] << 24) + ((UINT32)fp[5] << 16) +
((UINT32)fp[6] << 8) + (UINT32)fp[7];
- if (dFsize < (dSize + 8))
- {
- debug_error ("__AvCheckSizeOfMidFile Error/ Bad size [%ld] vs [%ld]\n", dFsize, dSize + 22);
+ if (dFsize < (dSize + 8)) {
+ debug_error("__AvCheckSizeOfMidFile Error/ Bad size [%ld] vs [%ld]\n", dFsize, dSize + 22);
return (AvSMW_ERROR_CHUNK_SIZE);
}
pI->TrackInfo[i].pbBase = &fp[8];
* set global
*/
gPi = pI;
-
+
return (__AvGetSizeOfFileInfo(pI));
}
static int
-__AvParseSkipXmf2Mid(UINT8* pbFile, UINT32 dFSize)
+__AvParseSkipXmf2Mid(UINT8 *pbFile, UINT32 dFSize)
{
- UINT32 skipVal = 0, sizeOfpbFile= dFSize;
- while(1)
- {
- if(pbFile[skipVal] == 'M' && pbFile[skipVal+1] == 'T' && pbFile[skipVal+2] == 'h' && pbFile[skipVal+3] == 'd')
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("__AvParseSkipForXMF : MThd Header found!\n");
- #endif
+ UINT32 skipVal = 0, sizeOfpbFile = dFSize;
+ while (1) {
+ if (pbFile[skipVal] == 'M' && pbFile[skipVal + 1] == 'T' && pbFile[skipVal + 2] == 'h' && pbFile[skipVal + 3] == 'd') {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("__AvParseSkipForXMF : MThd Header found!\n");
+#endif
break;
- }
- else
- {
+ } else {
skipVal++;
- if(skipVal >= sizeOfpbFile)
- {
- debug_error ("__AvParseSkipForXMF : MThd Header is not found!\n");
- debug_error ("__AvParseSkipForXMF :skipVal(%d) sizeOfpbFile(%d) \n", skipVal, sizeOfpbFile);
+ if (skipVal >= sizeOfpbFile) {
+ debug_error("__AvParseSkipForXMF : MThd Header is not found!\n");
+ debug_error("__AvParseSkipForXMF :skipVal(%d) sizeOfpbFile(%d) \n", skipVal, sizeOfpbFile);
return -1;
}
}
}
- // debug_msg("__AvParseSkipForXMF : skip value(%d)\n", skipVal);
+ /* debug_msg("__AvParseSkipForXMF : skip value(%d)\n", skipVal); */
return skipVal;
}
#define AVMASMW_ERROR_HV_CONFLICT (-26) /* conflict about HV resource */
#define AVMALIB_MAKEDWORD(a, b, c, d) (unsigned int)(((unsigned int)(a) << 24) | \
- ((unsigned int)(b) << 16) | ((unsigned int)(c) << 8) | (unsigned int)(d))
+ ((unsigned int)(b) << 16) | ((unsigned int)(c) << 8) | (unsigned int)(d))
/****************************************************************************
* define
* table
****************************************************************************/
static const unsigned short g_crc_tbl[256] = {
- 0x0000U,0x1021U,0x2042U,0x3063U,0x4084U,0x50A5U,0x60C6U,0x70E7U,
- 0x8108U,0x9129U,0xA14AU,0xB16BU,0xC18CU,0xD1ADU,0xE1CEU,0xF1EFU,
- 0x1231U,0x0210U,0x3273U,0x2252U,0x52B5U,0x4294U,0x72F7U,0x62D6U,
- 0x9339U,0x8318U,0xB37BU,0xA35AU,0xD3BDU,0xC39CU,0xF3FFU,0xE3DEU,
- 0x2462U,0x3443U,0x0420U,0x1401U,0x64E6U,0x74C7U,0x44A4U,0x5485U,
- 0xA56AU,0xB54BU,0x8528U,0x9509U,0xE5EEU,0xF5CFU,0xC5ACU,0xD58DU,
- 0x3653U,0x2672U,0x1611U,0x0630U,0x76D7U,0x66F6U,0x5695U,0x46B4U,
- 0xB75BU,0xA77AU,0x9719U,0x8738U,0xF7DFU,0xE7FEU,0xD79DU,0xC7BCU,
- 0x48C4U,0x58E5U,0x6886U,0x78A7U,0x0840U,0x1861U,0x2802U,0x3823U,
- 0xC9CCU,0xD9EDU,0xE98EU,0xF9AFU,0x8948U,0x9969U,0xA90AU,0xB92BU,
- 0x5AF5U,0x4AD4U,0x7AB7U,0x6A96U,0x1A71U,0x0A50U,0x3A33U,0x2A12U,
- 0xDBFDU,0xCBDCU,0xFBBFU,0xEB9EU,0x9B79U,0x8B58U,0xBB3BU,0xAB1AU,
- 0x6CA6U,0x7C87U,0x4CE4U,0x5CC5U,0x2C22U,0x3C03U,0x0C60U,0x1C41U,
- 0xEDAEU,0xFD8FU,0xCDECU,0xDDCDU,0xAD2AU,0xBD0BU,0x8D68U,0x9D49U,
- 0x7E97U,0x6EB6U,0x5ED5U,0x4EF4U,0x3E13U,0x2E32U,0x1E51U,0x0E70U,
- 0xFF9FU,0xEFBEU,0xDFDDU,0xCFFCU,0xBF1BU,0xAF3AU,0x9F59U,0x8F78U,
- 0x9188U,0x81A9U,0xB1CAU,0xA1EBU,0xD10CU,0xC12DU,0xF14EU,0xE16FU,
- 0x1080U,0x00A1U,0x30C2U,0x20E3U,0x5004U,0x4025U,0x7046U,0x6067U,
- 0x83B9U,0x9398U,0xA3FBU,0xB3DAU,0xC33DU,0xD31CU,0xE37FU,0xF35EU,
- 0x02B1U,0x1290U,0x22F3U,0x32D2U,0x4235U,0x5214U,0x6277U,0x7256U,
- 0xB5EAU,0xA5CBU,0x95A8U,0x8589U,0xF56EU,0xE54FU,0xD52CU,0xC50DU,
- 0x34E2U,0x24C3U,0x14A0U,0x0481U,0x7466U,0x6447U,0x5424U,0x4405U,
- 0xA7DBU,0xB7FAU,0x8799U,0x97B8U,0xE75FU,0xF77EU,0xC71DU,0xD73CU,
- 0x26D3U,0x36F2U,0x0691U,0x16B0U,0x6657U,0x7676U,0x4615U,0x5634U,
- 0xD94CU,0xC96DU,0xF90EU,0xE92FU,0x99C8U,0x89E9U,0xB98AU,0xA9ABU,
- 0x5844U,0x4865U,0x7806U,0x6827U,0x18C0U,0x08E1U,0x3882U,0x28A3U,
- 0xCB7DU,0xDB5CU,0xEB3FU,0xFB1EU,0x8BF9U,0x9BD8U,0xABBBU,0xBB9AU,
- 0x4A75U,0x5A54U,0x6A37U,0x7A16U,0x0AF1U,0x1AD0U,0x2AB3U,0x3A92U,
- 0xFD2EU,0xED0FU,0xDD6CU,0xCD4DU,0xBDAAU,0xAD8BU,0x9DE8U,0x8DC9U,
- 0x7C26U,0x6C07U,0x5C64U,0x4C45U,0x3CA2U,0x2C83U,0x1CE0U,0x0CC1U,
- 0xEF1FU,0xFF3EU,0xCF5DU,0xDF7CU,0xAF9BU,0xBFBAU,0x8FD9U,0x9FF8U,
- 0x6E17U,0x7E36U,0x4E55U,0x5E74U,0x2E93U,0x3EB2U,0x0ED1U,0x1EF0U
+ 0x0000U, 0x1021U, 0x2042U, 0x3063U, 0x4084U, 0x50A5U, 0x60C6U, 0x70E7U,
+ 0x8108U, 0x9129U, 0xA14AU, 0xB16BU, 0xC18CU, 0xD1ADU, 0xE1CEU, 0xF1EFU,
+ 0x1231U, 0x0210U, 0x3273U, 0x2252U, 0x52B5U, 0x4294U, 0x72F7U, 0x62D6U,
+ 0x9339U, 0x8318U, 0xB37BU, 0xA35AU, 0xD3BDU, 0xC39CU, 0xF3FFU, 0xE3DEU,
+ 0x2462U, 0x3443U, 0x0420U, 0x1401U, 0x64E6U, 0x74C7U, 0x44A4U, 0x5485U,
+ 0xA56AU, 0xB54BU, 0x8528U, 0x9509U, 0xE5EEU, 0xF5CFU, 0xC5ACU, 0xD58DU,
+ 0x3653U, 0x2672U, 0x1611U, 0x0630U, 0x76D7U, 0x66F6U, 0x5695U, 0x46B4U,
+ 0xB75BU, 0xA77AU, 0x9719U, 0x8738U, 0xF7DFU, 0xE7FEU, 0xD79DU, 0xC7BCU,
+ 0x48C4U, 0x58E5U, 0x6886U, 0x78A7U, 0x0840U, 0x1861U, 0x2802U, 0x3823U,
+ 0xC9CCU, 0xD9EDU, 0xE98EU, 0xF9AFU, 0x8948U, 0x9969U, 0xA90AU, 0xB92BU,
+ 0x5AF5U, 0x4AD4U, 0x7AB7U, 0x6A96U, 0x1A71U, 0x0A50U, 0x3A33U, 0x2A12U,
+ 0xDBFDU, 0xCBDCU, 0xFBBFU, 0xEB9EU, 0x9B79U, 0x8B58U, 0xBB3BU, 0xAB1AU,
+ 0x6CA6U, 0x7C87U, 0x4CE4U, 0x5CC5U, 0x2C22U, 0x3C03U, 0x0C60U, 0x1C41U,
+ 0xEDAEU, 0xFD8FU, 0xCDECU, 0xDDCDU, 0xAD2AU, 0xBD0BU, 0x8D68U, 0x9D49U,
+ 0x7E97U, 0x6EB6U, 0x5ED5U, 0x4EF4U, 0x3E13U, 0x2E32U, 0x1E51U, 0x0E70U,
+ 0xFF9FU, 0xEFBEU, 0xDFDDU, 0xCFFCU, 0xBF1BU, 0xAF3AU, 0x9F59U, 0x8F78U,
+ 0x9188U, 0x81A9U, 0xB1CAU, 0xA1EBU, 0xD10CU, 0xC12DU, 0xF14EU, 0xE16FU,
+ 0x1080U, 0x00A1U, 0x30C2U, 0x20E3U, 0x5004U, 0x4025U, 0x7046U, 0x6067U,
+ 0x83B9U, 0x9398U, 0xA3FBU, 0xB3DAU, 0xC33DU, 0xD31CU, 0xE37FU, 0xF35EU,
+ 0x02B1U, 0x1290U, 0x22F3U, 0x32D2U, 0x4235U, 0x5214U, 0x6277U, 0x7256U,
+ 0xB5EAU, 0xA5CBU, 0x95A8U, 0x8589U, 0xF56EU, 0xE54FU, 0xD52CU, 0xC50DU,
+ 0x34E2U, 0x24C3U, 0x14A0U, 0x0481U, 0x7466U, 0x6447U, 0x5424U, 0x4405U,
+ 0xA7DBU, 0xB7FAU, 0x8799U, 0x97B8U, 0xE75FU, 0xF77EU, 0xC71DU, 0xD73CU,
+ 0x26D3U, 0x36F2U, 0x0691U, 0x16B0U, 0x6657U, 0x7676U, 0x4615U, 0x5634U,
+ 0xD94CU, 0xC96DU, 0xF90EU, 0xE92FU, 0x99C8U, 0x89E9U, 0xB98AU, 0xA9ABU,
+ 0x5844U, 0x4865U, 0x7806U, 0x6827U, 0x18C0U, 0x08E1U, 0x3882U, 0x28A3U,
+ 0xCB7DU, 0xDB5CU, 0xEB3FU, 0xFB1EU, 0x8BF9U, 0x9BD8U, 0xABBBU, 0xBB9AU,
+ 0x4A75U, 0x5A54U, 0x6A37U, 0x7A16U, 0x0AF1U, 0x1AD0U, 0x2AB3U, 0x3A92U,
+ 0xFD2EU, 0xED0FU, 0xDD6CU, 0xCD4DU, 0xBDAAU, 0xAD8BU, 0x9DE8U, 0x8DC9U,
+ 0x7C26U, 0x6C07U, 0x5C64U, 0x4C45U, 0x3CA2U, 0x2C83U, 0x1CE0U, 0x0CC1U,
+ 0xEF1FU, 0xFF3EU, 0xCF5DU, 0xDF7CU, 0xAF9BU, 0xBFBAU, 0x8FD9U, 0x9FF8U,
+ 0x6E17U, 0x7E36U, 0x4E55U, 0x5E74U, 0x2E93U, 0x3EB2U, 0x0ED1U, 0x1EF0U
};
/* phase */
****************************************************************************/
/* OPDA infomation structure */
-typedef struct AvTagOptionInfo
-{
+typedef struct AvTagOptionInfo {
unsigned char *pbCnti; /* pointer to CNTI Body */
unsigned int dCntiSize; /* size of CNTI Body */
unsigned char *pbOpda; /* pointer to OPDA Body */
} OPTIONINFO, *POPTIONINFO;
/* Track information structure */
-typedef struct AvTagTrackInfo
-{
+typedef struct AvTagTrackInfo {
unsigned char *pbMtr; /* pointer to MTR(ATR) Body */
unsigned int dMtrSize; /* size of MTR(ATR) Body */
unsigned char *pbMspi; /* pointer to MspI(AspI) Body */
} TRACKINFO, *PTRACKINFO;
/* Phrase information structure */
-typedef struct AvTagPhraseInfo
-{
+typedef struct AvTagPhraseInfo {
unsigned int dStartPoint; /* start point of phrase(offset) */
unsigned int dStopPoint; /* stop point of phrase(offset) */
unsigned int dStartTick; /* start point of phrase(tick) */
} PHRASEINFO, *PPHRASEINFO;
/* Huffman information structure */
-typedef struct AvTagHuffmanInfo
-{
+typedef struct AvTagHuffmanInfo {
unsigned int dMtsqSize; /* size of Mtsq(Atsq) Body */
unsigned int dSeqSize; /* size of sequence data */
unsigned int dReadSize; /* read data size */
} HUFFMANINFO, *PHUFFMANINFO;
/* HV information structure */
-typedef struct AvTagHvInfo
-{
+typedef struct AvTagHvInfo {
unsigned char *pbVoice; /* pointer to HVP0 chunk header */
unsigned int dVoiceSize; /* size of HV voice parameter */
unsigned char *pbScript; /* pointer to Mhsc body */
/* Load information structure */
-typedef struct AvTagLoadInfo
-{
+typedef struct AvTagLoadInfo {
unsigned char *pbMmmd; /* pointer to MMMD top */
unsigned int dMmmdSize; /* size of MMMD (whole) */
unsigned int dCrc; /* file CRC */
unsigned int dPlayTime; /* play time (tick) */
unsigned int dStartTime; /* start time (start point tick) */
unsigned int dTimeBase; /* time base (msec/tick) */
- unsigned char (*pfnGetByte)(PHUFFMANINFO psHuf);
+ unsigned char(*pfnGetByte)(PHUFFMANINFO psHuf);
OPTIONINFO sOption_Info;
TRACKINFO sTrack_Info[AV_MMF_MAX_TRACK_NUM];
PHRASEINFO sPhrase_Info[AV_MMF_MAX_PHRASE_INFO];
} LOADINFO, *PLOADINFO;
/* Stream information structure(for MA-2) */
-typedef struct AvTagStreamInfo2
-{
+typedef struct AvTagStreamInfo2 {
unsigned char bStrmID; /* key number of stream */
unsigned char *pbWave; /* pointer to Awa body */
unsigned int dWaveSize; /* size of Awa body */
} STREAMINFO2, *PSTREAMINFO2;
/* Stream information structure(for MA-3/5) */
-typedef struct AvTagStreamInfo3
-{
+typedef struct AvTagStreamInfo3 {
unsigned char fbNote; /* stream data flag */
unsigned char bPairID; /* stream pair ID */
unsigned char bPan; /* stream pan */
} STREAMINFO3, *PSTREAMINFO3;
/* Stream information structure */
-typedef struct AvTagStreamInfo
-{
+typedef struct AvTagStreamInfo {
STREAMINFO2 sStream_Info2[AV_MMF_MAX_STREAM_DATA_NUM2];
STREAMINFO3 sStream_Info3[AV_MMF_MAX_STREAM_DATA_NUM3];
} STREAMINFO, *PSTREAMINFO;
/* Voice information structure(for MA-1/2) */
-typedef struct AvTagVoiceInfo2
-{
+typedef struct AvTagVoiceInfo2 {
unsigned char bBank; /* bank number */
unsigned char bProg; /* program number */
} VOICEINFO2, *PVOICEINFO2;
/* Wave information structure(for MA-3/5) */
-typedef struct AvTagWaveInfo3
-{
+typedef struct AvTagWaveInfo3 {
unsigned int dAdrs; /* wave address */
unsigned int dSize; /* wave data size */
} WAVEINFO3, *PWAVEINFO3;
/* Voice information structure */
-typedef struct AvTagVoiceInfo
-{
+typedef struct AvTagVoiceInfo {
VOICEINFO2 sVoice_Info2[AV_MMF_MAX_VOICE_DATA_NUM2];
WAVEINFO3 sWave_Info3[AV_MMF_MAX_WAVE_DATA_NUM3];
} VOICEINFO, *PVOICEINFO;
/* Channel information structure */
-typedef struct AvTagChannelInfo
-{
+typedef struct AvTagChannelInfo {
unsigned char bBankM; /* bank select MSB */
unsigned char bBankL; /* bank select LSB */
unsigned char bBank; /* bank number (sound driver) */
} CHANNELINFO, *PCHANNELINFO;
/* Event information structure */
-typedef struct AvTagEventBlock
-{
+typedef struct AvTagEventBlock {
unsigned int dEventTime; /* event activation time */
unsigned int dSeqID; /* sequencer ID (sound driver) */
unsigned int dCmd; /* command ID (sound driver) */
unsigned char *pbSeq; /* pointer to next event data */
unsigned int dIndex; /* index of next event */
unsigned int dTrackNo; /* track no. */
- void * pvNext; /* pointer to next event block */
+ void *pvNext; /* pointer to next event block */
} EVENTBLOCK, *PEVENTBLOCK;
/* Note OFF information structure */
-typedef struct AvTagNoteOffBlock
-{
+typedef struct AvTagNoteOffBlock {
unsigned int dOffTime; /* note off activation time */
unsigned int dSeqID; /* sequencer ID (sound driver) */
unsigned int dCmd; /* command ID (sound driver) */
unsigned int dCh; /* channel no. */
unsigned int dKey; /* key no. */
- void * pvNext; /* pointer to next note off block */
+ void *pvNext; /* pointer to next note off block */
} OFFBLOCK, *POFFBLOCK;
/* Playback information structure */
-typedef struct AvTagPlayInfo
-{
+typedef struct AvTagPlayInfo {
PEVENTBLOCK psNextEvent; /* pointer to next event block */
PEVENTBLOCK psEmptyEvent; /* pointer to empty event block */
POFFBLOCK psNextOff; /* pointer to next note off block */
} PLAYINFO, *PPLAYINFO;
/* SMAF information structure */
-typedef struct AvTagSmafInfo
-{
+typedef struct AvTagSmafInfo {
int sdMmfSeqID; /* sequence id (sound driver) */
unsigned int dStatus; /* converter status */
LOADINFO sLoad_Info[2];
static const unsigned short g_awBitMaskTable2[8] = {0x00FF, 0x01FE, 0x03FC, 0x07F8, 0x0FF0, 0x1FE0, 0x3FC0, 0x7F80};
static const unsigned char g_abTableA[16] = {0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15};
static const unsigned char g_abTableD[16] = {0, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
-static const unsigned char g_abExpression2[16] = {0x80,0x00,0x1f,0x27,0x2f,0x37,0x3f,0x47,0x4f,0x57,0x5f,0x67,0x6f,0x77,0x7f,0x80};
-static const unsigned char g_abModulation2[16] = {0x80,0x00,0x08,0x10,0x18,0x20,0x28,0x30,0x38,0x40,0x48,0x50,0x60,0x70,0x7f,0x80};
+static const unsigned char g_abExpression2[16] = {0x80, 0x00, 0x1f, 0x27, 0x2f, 0x37, 0x3f, 0x47, 0x4f, 0x57, 0x5f, 0x67, 0x6f, 0x77, 0x7f, 0x80};
+static const unsigned char g_abModulation2[16] = {0x80, 0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38, 0x40, 0x48, 0x50, 0x60, 0x70, 0x7f, 0x80};
/**
* Define.
/* internals */
-static int mmf_file_mmf_get_duration (char *src, int is_xmf);
+static int mmf_file_mmf_get_duration(char *src, int is_xmf);
/* mm plugin porting */
/* plugin manadatory API */
-int mmfile_format_read_stream_mmf (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_mmf (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_mmf (MMFileFormatContext *formatContext);
-int mmfile_format_close_mmf (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_mmf(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_mmf(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_mmf(MMFileFormatContext *formatContext);
+int mmfile_format_close_mmf(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_mmf (MMFileFormatContext *formatContext)
+int mmfile_format_open_mmf(MMFileFormatContext *formatContext)
{
int ret = 0;
if (NULL == formatContext) {
- debug_error ("error: formatContext is NULL\n");
+ debug_error("error: formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
- ret = MMFileFormatIsValidMMF (NULL, formatContext->uriFileName);
+ ret = MMFileFormatIsValidMMF(NULL, formatContext->uriFileName);
if (ret == 0) {
- debug_error ("error: it is not MMF file\n");
+ debug_error("error: it is not MMF file\n");
return MMFILE_FORMAT_FAIL;
}
}
}
EXPORT_API
-int mmfile_format_read_stream_mmf (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_mmf(MMFileFormatContext *formatContext)
{
- int total = 0;
-
- total = mmf_file_mmf_get_duration (formatContext->uriFileName, 0 /*not XMF*/);
- if ( total < 0 )
- {
- debug_error ("error: get duration\n");
- return MMFILE_FORMAT_FAIL;
- }
-
-
- formatContext->duration = total;
- formatContext->audioTotalTrackNum = 1;
- formatContext->nbStreams = 1;
- formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc (sizeof(MMFileFormatStream));
- if (NULL == formatContext->streams[MMFILE_AUDIO_STREAM])
- {
- debug_error ("error: mmfile_malloc, audido stream\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- formatContext->streams[MMFILE_AUDIO_STREAM]->codecId =MM_AUDIO_CODEC_MMF;
- formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = 1;
-
- return MMFILE_FORMAT_SUCCESS;
+ int total = 0;
+
+ total = mmf_file_mmf_get_duration(formatContext->uriFileName, 0 /*not XMF*/);
+ if (total < 0) {
+ debug_error("error: get duration\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+
+ formatContext->duration = total;
+ formatContext->audioTotalTrackNum = 1;
+ formatContext->nbStreams = 1;
+ formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc(sizeof(MMFileFormatStream));
+ if (NULL == formatContext->streams[MMFILE_AUDIO_STREAM]) {
+ debug_error("error: mmfile_malloc, audido stream\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ formatContext->streams[MMFILE_AUDIO_STREAM]->codecId = MM_AUDIO_CODEC_MMF;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = 1;
+
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_frame_mmf (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_mmf(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_tag_mmf (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_mmf(MMFileFormatContext *formatContext)
{
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_close_mmf (MMFileFormatContext *formatContext)
+int mmfile_format_close_mmf(MMFileFormatContext *formatContext)
{
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
}
* nothing
********************************************************************************/
static unsigned int
-_mmf_Get4Byte(unsigned char* pbBuf)
+_mmf_Get4Byte(unsigned char *pbBuf)
{
- return (unsigned int)( (((unsigned int)pbBuf[0]) << 24) +
- (((unsigned int)pbBuf[1]) << 16) +
- (((unsigned int)pbBuf[2]) << 8) +
- ((unsigned int)pbBuf[3]));
+ return (unsigned int)((((unsigned int)pbBuf[0]) << 24) +
+ (((unsigned int)pbBuf[1]) << 16) +
+ (((unsigned int)pbBuf[2]) << 8) +
+ ((unsigned int)pbBuf[3]));
}
{
unsigned char i;
-/* Initialize Load information structure */
+ /* Initialize Load information structure */
psLoad->pbMmmd = NULL;
psLoad->dMmmdSize = 0;
psLoad->dCrc = AV_MMF_CRC_NULL;
psLoad->sOption_Info.pbOpda = NULL;
psLoad->sOption_Info.dOpdaSize = 0;
- for ( i = 0; i < AV_MMF_MAX_TRACK_NUM; i++)
- {
+ for (i = 0; i < AV_MMF_MAX_TRACK_NUM; i++) {
psLoad->sTrack_Info[i].pbMtr = NULL;
psLoad->sTrack_Info[i].dMtrSize = 0;
psLoad->sTrack_Info[i].pbMspi = NULL;
psLoad->sTrack_Info[i].dStopTick = AV_MMF_STSP_TIME_NULL;
}
- for ( i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++)
- {
+ for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
psLoad->sPhrase_Info[i].dStartPoint = AV_MMF_STSP_OFFSET_NULL;
psLoad->sPhrase_Info[i].dStopPoint = AV_MMF_STSP_OFFSET_NULL;
psLoad->sPhrase_Info[i].dStartTick = AV_MMF_STSP_TIME_NULL;
static int
_mmf_GetTimebase(unsigned char bData)
{
- switch ( bData )
- {
- case 0x02: return 4; /* 4[msec/tick] */
- case 0x03: return 5; /* 5[msec/tick] */
- case 0x10: return 10; /* 10[msec/tick] */
- case 0x11: return 20; /* 20[msec/tick] */
- case 0x12: return 40; /* 40[msec/tick] */
- case 0x13: return 50; /* 50[msec/tick] */
- default: return AV_MMF_FUNC_ERROR; /* Time Base Error */
+ switch (bData) {
+ case 0x02:
+ return 4; /* 4[msec/tick] */
+ case 0x03:
+ return 5; /* 5[msec/tick] */
+ case 0x10:
+ return 10; /* 10[msec/tick] */
+ case 0x11:
+ return 20; /* 20[msec/tick] */
+ case 0x12:
+ return 40; /* 40[msec/tick] */
+ case 0x13:
+ return 50; /* 50[msec/tick] */
+ default:
+ return AV_MMF_FUNC_ERROR; /* Time Base Error */
}
}
static int
-_mmf_MalibNextChunk(unsigned char* pbFile, unsigned int dSize, unsigned int dState, unsigned int* pdChunkID, unsigned int* pdChunkNo)
+_mmf_MalibNextChunk(unsigned char *pbFile, unsigned int dSize, unsigned int dState, unsigned int *pdChunkID, unsigned int *pdChunkNo)
{
unsigned int dChunkID, dChunkSize;
dChunkID = AVMALIB_MAKEDWORD(pbFile[0], pbFile[1], pbFile[2], pbFile[3]);
dChunkSize = AVMALIB_MAKEDWORD(pbFile[4], pbFile[5], pbFile[6], pbFile[7]);
- switch (dChunkID)
- {
- case AVMALIB_CHUNKID_MMMD :
- *pdChunkID = AVMALIB_CHUNKCODE_MMMD;
- if (dState != AVMALIB_CHUNK_PHASE_MMMD)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_CNTI :
- *pdChunkID = AVMALIB_CHUNKCODE_CNTI;
- if (dState != AVMALIB_CHUNK_PHASE_CNTI)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_OPDA :
- *pdChunkID = AVMALIB_CHUNKCODE_OPDA;
- if (dState != AVMALIB_CHUNK_PHASE_MMMDSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_MSPI :
- *pdChunkID = AVMALIB_CHUNKCODE_MSPI;
- if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_MTSU :
- *pdChunkID = AVMALIB_CHUNKCODE_MTSU;
- if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_MTSQ :
- *pdChunkID = AVMALIB_CHUNKCODE_MTSQ;
- if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_MTSP :
- *pdChunkID = AVMALIB_CHUNKCODE_MTSP;
- if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_ASPI :
- *pdChunkID = AVMALIB_CHUNKCODE_ASPI;
- if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_ATSU :
- *pdChunkID = AVMALIB_CHUNKCODE_ATSU;
- if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_ATSQ :
- *pdChunkID = AVMALIB_CHUNKCODE_ATSQ;
- if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
-
- case AVMALIB_CHUNKID_MTHV :
- *pdChunkID = AVMALIB_CHUNKCODE_MTHV;
- if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_MHVS :
- *pdChunkID = AVMALIB_CHUNKCODE_MHVS;
- if (dState != AVMALIB_CHUNK_PHASE_MTHVSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
- case AVMALIB_CHUNKID_MHSC :
- *pdChunkID = AVMALIB_CHUNKCODE_MHSC;
- if (dState != AVMALIB_CHUNK_PHASE_MTHVSUB)
- return AVMALIB_CHUNK_ID_ERROR;
- break;
-
- default :
- *pdChunkNo = (unsigned char)(dChunkID & 0x000000FF);
- switch (dChunkID & 0xFFFFFF00)
- {
- case AVMALIB_CHUNKID_MTR :
- *pdChunkID = AVMALIB_CHUNKCODE_MTR;
- if (dState != AVMALIB_CHUNK_PHASE_MMMDSUB)
+ switch (dChunkID) {
+ case AVMALIB_CHUNKID_MMMD:
+ *pdChunkID = AVMALIB_CHUNKCODE_MMMD;
+ if (dState != AVMALIB_CHUNK_PHASE_MMMD)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_CNTI:
+ *pdChunkID = AVMALIB_CHUNKCODE_CNTI;
+ if (dState != AVMALIB_CHUNK_PHASE_CNTI)
return AVMALIB_CHUNK_ID_ERROR;
break;
- case AVMALIB_CHUNKID_ATR :
- *pdChunkID = AVMALIB_CHUNKCODE_ATR;
+ case AVMALIB_CHUNKID_OPDA:
+ *pdChunkID = AVMALIB_CHUNKCODE_OPDA;
if (dState != AVMALIB_CHUNK_PHASE_MMMDSUB)
return AVMALIB_CHUNK_ID_ERROR;
break;
-
- case AVMALIB_CHUNKID_DCH :
- *pdChunkID = AVMALIB_CHUNKCODE_DCH;
- if (dState != AVMALIB_CHUNK_PHASE_OPDASUB)
+ case AVMALIB_CHUNKID_MSPI:
+ *pdChunkID = AVMALIB_CHUNKCODE_MSPI;
+ if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
return AVMALIB_CHUNK_ID_ERROR;
break;
- case AVMALIB_CHUNKID_M5P :
- *pdChunkID = AVMALIB_CHUNKCODE_M5P;
- if (dState != AVMALIB_CHUNK_PHASE_OPDASUB)
+ case AVMALIB_CHUNKID_MTSU:
+ *pdChunkID = AVMALIB_CHUNKCODE_MTSU;
+ if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
return AVMALIB_CHUNK_ID_ERROR;
break;
-
- case AVMALIB_CHUNKID_MWA :
- *pdChunkID = AVMALIB_CHUNKCODE_MWA;
- if (dState != AVMALIB_CHUNK_PHASE_MTSPSUB)
+ case AVMALIB_CHUNKID_MTSQ:
+ *pdChunkID = AVMALIB_CHUNKCODE_MTSQ;
+ if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
return AVMALIB_CHUNK_ID_ERROR;
break;
-
- case AVMALIB_CHUNKID_AWA :
- *pdChunkID = AVMALIB_CHUNKCODE_AWA;
+ case AVMALIB_CHUNKID_MTSP:
+ *pdChunkID = AVMALIB_CHUNKCODE_MTSP;
+ if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_ASPI:
+ *pdChunkID = AVMALIB_CHUNKCODE_ASPI;
+ if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_ATSU:
+ *pdChunkID = AVMALIB_CHUNKCODE_ATSU;
+ if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_ATSQ:
+ *pdChunkID = AVMALIB_CHUNKCODE_ATSQ;
if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
return AVMALIB_CHUNK_ID_ERROR;
break;
- case AVMALIB_CHUNKID_HVP :
- *pdChunkID = AVMALIB_CHUNKCODE_HVP;
+ case AVMALIB_CHUNKID_MTHV:
+ *pdChunkID = AVMALIB_CHUNKCODE_MTHV;
+ if (dState != AVMALIB_CHUNK_PHASE_MTRSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_MHVS:
+ *pdChunkID = AVMALIB_CHUNKCODE_MHVS;
if (dState != AVMALIB_CHUNK_PHASE_MTHVSUB)
return AVMALIB_CHUNK_ID_ERROR;
break;
+ case AVMALIB_CHUNKID_MHSC:
+ *pdChunkID = AVMALIB_CHUNKCODE_MHSC;
+ if (dState != AVMALIB_CHUNK_PHASE_MTHVSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+
+ default:
+ *pdChunkNo = (unsigned char)(dChunkID & 0x000000FF);
+ switch (dChunkID & 0xFFFFFF00) {
+ case AVMALIB_CHUNKID_MTR:
+ *pdChunkID = AVMALIB_CHUNKCODE_MTR;
+ if (dState != AVMALIB_CHUNK_PHASE_MMMDSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_ATR:
+ *pdChunkID = AVMALIB_CHUNKCODE_ATR;
+ if (dState != AVMALIB_CHUNK_PHASE_MMMDSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+
+ case AVMALIB_CHUNKID_DCH:
+ *pdChunkID = AVMALIB_CHUNKCODE_DCH;
+ if (dState != AVMALIB_CHUNK_PHASE_OPDASUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+ case AVMALIB_CHUNKID_M5P:
+ *pdChunkID = AVMALIB_CHUNKCODE_M5P;
+ if (dState != AVMALIB_CHUNK_PHASE_OPDASUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+
+ case AVMALIB_CHUNKID_MWA:
+ *pdChunkID = AVMALIB_CHUNKCODE_MWA;
+ if (dState != AVMALIB_CHUNK_PHASE_MTSPSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
- default :
- *pdChunkID = AVMALIB_CHUNKCODE_UNKNOWN;
+ case AVMALIB_CHUNKID_AWA:
+ *pdChunkID = AVMALIB_CHUNKCODE_AWA;
+ if (dState != AVMALIB_CHUNK_PHASE_ATRSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+
+ case AVMALIB_CHUNKID_HVP:
+ *pdChunkID = AVMALIB_CHUNKCODE_HVP;
+ if (dState != AVMALIB_CHUNK_PHASE_MTHVSUB)
+ return AVMALIB_CHUNK_ID_ERROR;
+ break;
+
+ default:
+ *pdChunkID = AVMALIB_CHUNKCODE_UNKNOWN;
+ break;
+ }
break;
- }
- break;
}
if (dChunkSize > (dSize - AVMALIB_SIZE_OF_CHUNKHEADER))
{
int sdResult, sdChunkSize;
unsigned int dSize, dIndex;
- unsigned char* pbBuf;
+ unsigned char *pbBuf;
unsigned int dChunkID, dChunkNo;
-/* Check Format Type */
- switch (bSmafType)
- {
- case AV_MMF_SMAF_TYPE_MA1 :
- case AV_MMF_SMAF_TYPE_MA2 :
- if (psTrack->pbMtr[0] != 0x00)
- {
- return AV_MMF_ERR_CHUNK;
- }
- break;
- case AV_MMF_SMAF_TYPE_MA3 :
- if ((psTrack->pbMtr[0] != 0x01) && (psTrack->pbMtr[0] != 0x02))
- {
- return AV_MMF_ERR_CHUNK;
- }
- break;
- case AV_MMF_SMAF_TYPE_MA5 :
- if (psTrack->pbMtr[0] != 0x02)
- {
- return AV_MMF_ERR_CHUNK;
- }
- break;
- default :
- break;
+ /* Check Format Type */
+ switch (bSmafType) {
+ case AV_MMF_SMAF_TYPE_MA1:
+ case AV_MMF_SMAF_TYPE_MA2:
+ if (psTrack->pbMtr[0] != 0x00) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ break;
+ case AV_MMF_SMAF_TYPE_MA3:
+ if ((psTrack->pbMtr[0] != 0x01) && (psTrack->pbMtr[0] != 0x02)) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ break;
+ case AV_MMF_SMAF_TYPE_MA5:
+ if (psTrack->pbMtr[0] != 0x02) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ break;
+ default:
+ break;
}
-/* Check Sequence Type */
- if (psTrack->pbMtr[1] != 0x00)
- {
+ /* Check Sequence Type */
+ if (psTrack->pbMtr[1] != 0x00) {
return AV_MMF_ERR_CHUNK;
}
-/* Check Time Base */
- if (psTrack->pbMtr[2] != psTrack->pbMtr[3])
- {
+ /* Check Time Base */
+ if (psTrack->pbMtr[2] != psTrack->pbMtr[3]) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_GetTimebase(psTrack->pbMtr[2]);
- if (sdResult == AV_MMF_FUNC_ERROR)
- {
+ if (sdResult == AV_MMF_FUNC_ERROR) {
return AV_MMF_ERR_CHUNK;
}
psTrack->dTimeBase = (unsigned int)sdResult;
-/* Check sub chunk disposition */
+ /* Check sub chunk disposition */
if ((bSmafType == AV_MMF_SMAF_TYPE_MA1) || (bSmafType == AV_MMF_SMAF_TYPE_MA2))
dIndex = AV_MMF_MINIMUM_TRACKSIZE2;
else
dIndex = AV_MMF_MINIMUM_TRACKSIZE3;
pbBuf = psTrack->pbMtr;
dSize = psTrack->dMtrSize;
- while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE))
- {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize-dIndex),
- AVMALIB_CHUNK_PHASE_MTRSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0)
- {
+ while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
+ sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex),
+ AVMALIB_CHUNK_PHASE_MTRSUB, &dChunkID, &dChunkNo);
+ if (sdChunkSize < 0) {
return AV_MMF_ERR_CHUNK;
}
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
switch (dChunkID) {
- case AVMALIB_CHUNKCODE_MSPI :
- psTrack->pbMspi = &(pbBuf[dIndex]);
- psTrack->dMspiSize = sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_MTSU :
- psTrack->pbMtsu = &(pbBuf[dIndex]);
- psTrack->dMtsuSize = sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_MTSQ :
- psTrack->pbMtsq = &(pbBuf[dIndex]);
- psTrack->dMtsqSize = sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_MTSP :
- psTrack->pbMtsp = &(pbBuf[dIndex]);
- psTrack->dMtspSize = sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_MTHV :
- psTrack->pbMthv = &(pbBuf[dIndex]);
- psTrack->dMthvSize = sdChunkSize;
- break;
- default :
- break;
+ case AVMALIB_CHUNKCODE_MSPI:
+ psTrack->pbMspi = &(pbBuf[dIndex]);
+ psTrack->dMspiSize = sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_MTSU:
+ psTrack->pbMtsu = &(pbBuf[dIndex]);
+ psTrack->dMtsuSize = sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_MTSQ:
+ psTrack->pbMtsq = &(pbBuf[dIndex]);
+ psTrack->dMtsqSize = sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_MTSP:
+ psTrack->pbMtsp = &(pbBuf[dIndex]);
+ psTrack->dMtspSize = sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_MTHV:
+ psTrack->pbMthv = &(pbBuf[dIndex]);
+ psTrack->dMthvSize = sdChunkSize;
+ break;
+ default:
+ break;
}
dIndex += sdChunkSize;
}
- if ((psTrack->pbMtsq == NULL) ||(psTrack->dMtsqSize == 0))
- {
+ if ((psTrack->pbMtsq == NULL) || (psTrack->dMtsqSize == 0)) {
return AV_MMF_ERR_SLENGTH;
}
return AV_MMF_FUNC_SUCCESS;
{
int sdResult, sdChunkSize;
unsigned int dSize, dIndex;
- unsigned char* pbBuf;
+ unsigned char *pbBuf;
unsigned int dChunkID, dChunkNo;
unsigned char fbWave;
-/* Check Format Type */
- if (psTrack->pbMtr[0] != 0x00)
- {
+ /* Check Format Type */
+ if (psTrack->pbMtr[0] != 0x00) {
return AV_MMF_ERR_CHUNK;
}
-/* Check Sequence Type */
- if (psTrack->pbMtr[1] != 0x00)
- {
+ /* Check Sequence Type */
+ if (psTrack->pbMtr[1] != 0x00) {
return AV_MMF_ERR_CHUNK;
}
-/* Check Wave Type */
+ /* Check Wave Type */
if (((psTrack->pbMtr[2] != 0x10) && (psTrack->pbMtr[2] != 0x11)) ||
- ((psTrack->pbMtr[3] & 0xF0) != 0x00))
- {
+ ((psTrack->pbMtr[3] & 0xF0) != 0x00)) {
return AV_MMF_ERR_CHUNK;
}
-/* Check Time Base */
- if (psTrack->pbMtr[4] != psTrack->pbMtr[5])
- {
+ /* Check Time Base */
+ if (psTrack->pbMtr[4] != psTrack->pbMtr[5]) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_GetTimebase(psTrack->pbMtr[4]);
- if (sdResult == AV_MMF_FUNC_ERROR)
- {
+ if (sdResult == AV_MMF_FUNC_ERROR) {
return AV_MMF_ERR_CHUNK;
}
psTrack->dTimeBase = (unsigned int)sdResult;
dIndex = 6;
fbWave = AV_MMF_MA2_VOICE_NULL;
-/* Check sub chunk disposition */
- while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE))
- {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize-dIndex),
- AVMALIB_CHUNK_PHASE_ATRSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0)
- {
+ /* Check sub chunk disposition */
+ while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
+ sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex),
+ AVMALIB_CHUNK_PHASE_ATRSUB, &dChunkID, &dChunkNo);
+ if (sdChunkSize < 0) {
return AV_MMF_ERR_CHUNK;
}
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
- switch (dChunkID)
- {
- case AVMALIB_CHUNKCODE_ASPI :
- psTrack->pbMspi = &(pbBuf[dIndex]);
- psTrack->dMspiSize = sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_ATSQ :
- psTrack->pbMtsq = &(pbBuf[dIndex]);
- psTrack->dMtsqSize = sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_AWA :
- if ((0x01 <= dChunkNo) && (dChunkNo <= 0x3E))
- fbWave = AV_MMF_MA2_VOICE_FOUND;
- break;
- default :
- break;
+ switch (dChunkID) {
+ case AVMALIB_CHUNKCODE_ASPI:
+ psTrack->pbMspi = &(pbBuf[dIndex]);
+ psTrack->dMspiSize = sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_ATSQ:
+ psTrack->pbMtsq = &(pbBuf[dIndex]);
+ psTrack->dMtsqSize = sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_AWA:
+ if ((0x01 <= dChunkNo) && (dChunkNo <= 0x3E))
+ fbWave = AV_MMF_MA2_VOICE_FOUND;
+ break;
+ default:
+ break;
}
dIndex += sdChunkSize;
}
- if ((psTrack->pbMtsq == NULL) ||(psTrack->dMtsqSize == 0) ||(fbWave == AV_MMF_MA2_VOICE_NULL))
- {
+ if ((psTrack->pbMtsq == NULL) || (psTrack->dMtsqSize == 0) || (fbWave == AV_MMF_MA2_VOICE_NULL)) {
return AV_MMF_ERR_SLENGTH;
}
return AV_MMF_FUNC_SUCCESS;
static void
_mmf_MspICheck(PTRACKINFO psTrack, PPHRASEINFO psPhrase)
{
- unsigned char* pbBuf;
+ unsigned char *pbBuf;
unsigned int dSize, dIndex;
unsigned short wTag;
dSize = psTrack->dMspiSize;
dIndex = 0;
- while (dSize >= dIndex + AV_MMF_PHRAZE_SIZE_A)
- {
- wTag = (unsigned short)((((unsigned short)pbBuf[dIndex]) << 8) + (unsigned short)pbBuf[dIndex+1]);
+ while (dSize >= dIndex + AV_MMF_PHRAZE_SIZE_A) {
+ wTag = (unsigned short)((((unsigned short)pbBuf[dIndex]) << 8) + (unsigned short)pbBuf[dIndex + 1]);
switch (wTag) {
- case AV_MMF_TAG_STARTPOINT : /* start point */
- psTrack->dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- dIndex += AV_MMF_PHRAZE_SIZE_A;
- break;
- case AV_MMF_TAG_STOPPOINT : /* stop point */
- psTrack->dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- dIndex += AV_MMF_PHRAZE_SIZE_A;
- break;
- case AV_MMF_TAG_PHRASE_A : /* A melody */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[0].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[0].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- case AV_MMF_TAG_PHRASE_B : /* B melody */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[1].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[1].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- case AV_MMF_TAG_PHRASE_E : /* Ending */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[2].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[2].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- case AV_MMF_TAG_PHRASE_I : /* Intro */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[3].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[3].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- case AV_MMF_TAG_PHRASE_K : /* Interlude */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[4].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[4].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- case AV_MMF_TAG_PHRASE_R : /* Refrain */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[5].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[5].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- case AV_MMF_TAG_PHRASE_S : /* Bridge */
- if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
- return ;
- psPhrase[6].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
- psPhrase[6].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
- dIndex += AV_MMF_PHRAZE_SIZE_B;
- break;
- default :
- return;
+ case AV_MMF_TAG_STARTPOINT: /* start point */
+ psTrack->dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ dIndex += AV_MMF_PHRAZE_SIZE_A;
+ break;
+ case AV_MMF_TAG_STOPPOINT: /* stop point */
+ psTrack->dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ dIndex += AV_MMF_PHRAZE_SIZE_A;
+ break;
+ case AV_MMF_TAG_PHRASE_A: /* A melody */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[0].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[0].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ case AV_MMF_TAG_PHRASE_B: /* B melody */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[1].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[1].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ case AV_MMF_TAG_PHRASE_E: /* Ending */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[2].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[2].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ case AV_MMF_TAG_PHRASE_I: /* Intro */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[3].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[3].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ case AV_MMF_TAG_PHRASE_K: /* Interlude */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[4].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[4].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ case AV_MMF_TAG_PHRASE_R: /* Refrain */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[5].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[5].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ case AV_MMF_TAG_PHRASE_S: /* Bridge */
+ if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
+ return ;
+ psPhrase[6].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
+ psPhrase[6].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
+ dIndex += AV_MMF_PHRAZE_SIZE_B;
+ break;
+ default:
+ return;
}
}
return;
* < 0 error code
********************************************************************************/
static int
-_mmf_STSPCheck( PTRACKINFO psTrack)
+_mmf_STSPCheck(PTRACKINFO psTrack)
{
unsigned int dStart, dStop, dSize;
static int
_mmf_MtsuCheck2(PTRACKINFO psTrack, unsigned char bSmafType)
{
- unsigned char* pbBuf;
+ unsigned char *pbBuf;
unsigned int dSize, dIndex;
- if (psTrack->pbMtsu == NULL)
- {
+ if (psTrack->pbMtsu == NULL) {
return AV_MMF_MA2_VOICE_NOTFOUND;
}
dSize = psTrack->dMtsuSize;
dIndex = 0;
- while (dSize > dIndex + 20)
- {
- if ((pbBuf[dIndex] != 0xFF) || (pbBuf[dIndex + 1] != 0xF0))
- {
+ while (dSize > dIndex + 20) {
+ if ((pbBuf[dIndex] != 0xFF) || (pbBuf[dIndex + 1] != 0xF0)) {
return AV_MMF_MA2_VOICE_NOTFOUND;
}
- if (pbBuf[dIndex + 3] == 0x43)
- {
+ if (pbBuf[dIndex + 3] == 0x43) {
if ((bSmafType == AV_MMF_SMAF_TYPE_MA1) && (pbBuf[dIndex + 4] == 0x02))
return AV_MMF_MA2_VOICE_FOUND;
if ((bSmafType == AV_MMF_SMAF_TYPE_MA2) && (pbBuf[dIndex + 4] == 0x03))
* < 0 error code
********************************************************************************/
static int
-_mmf_GetFlex2L(unsigned char* pbBuf, unsigned int dSize, unsigned int* pbRead)
+_mmf_GetFlex2L(unsigned char *pbBuf, unsigned int dSize, unsigned int *pbRead)
{
int sdTemp;
if ((dSize < 1) || ((dSize < 2) && (pbBuf[0] >= 0x80)))
return AV_MMF_FUNC_ERROR;
- if (dSize >= 4)
- {
+ if (dSize >= 4) {
sdTemp = pbBuf[0] + pbBuf[1] + pbBuf[2] + pbBuf[3];
if (sdTemp == 0)
return AV_MMF_FUNC_ERROR;
}
- if (pbBuf[0] >= 0x80)
- {
- sdTemp = (int)( (((int)(pbBuf[0] & 0x7F)) << 7) +
- ((int)(pbBuf[1] & 0x7F)) + 128 );
+ if (pbBuf[0] >= 0x80) {
+ sdTemp = (int)((((int)(pbBuf[0] & 0x7F)) << 7) +
+ ((int)(pbBuf[1] & 0x7F)) + 128);
*pbRead = 2;
- }
- else
- {
+ } else {
sdTemp = (int)(pbBuf[0] & 0x7F);
*pbRead = 1;
}
static int
_mmf_SeqDataCheck2(PTRACKINFO psTrack, unsigned char bSmafType)
{
- unsigned char* pbBuf;
+ unsigned char *pbBuf;
unsigned int dSize, dIndex;
int sdTemp;
unsigned int dPast, dGate, dFlexSize;
- if (psTrack->pbMtsq == NULL)
- {
+ if (psTrack->pbMtsq == NULL) {
return AV_MMF_ERR_SLENGTH;
}
dSize = psTrack->dMtsqSize;
dIndex = 0;
-/* scanning to EOS or stop point */
- while ( dSize > dIndex )
- {
- if (psTrack->dStartPoint== dIndex) /* start point */
+ /* scanning to EOS or stop point */
+ while (dSize > dIndex) {
+ if (psTrack->dStartPoint == dIndex) /* start point */
psTrack->dStartTick = dPast;
- if (psTrack->dStopPoint == dIndex)
- { /* stop point */
+ if (psTrack->dStopPoint == dIndex) {
+ /* stop point */
psTrack->dStopTick = dPast;
break;
}
- if (dSize >= dIndex + 4)
- {
- sdTemp=pbBuf[dIndex]+pbBuf[dIndex+1]+pbBuf[dIndex+2]+pbBuf[dIndex+3];
- if (sdTemp == 0)
- { /* EOS */
+ if (dSize >= dIndex + 4) {
+ sdTemp = pbBuf[dIndex] + pbBuf[dIndex + 1] + pbBuf[dIndex + 2] + pbBuf[dIndex + 3];
+ if (sdTemp == 0) {
+ /* EOS */
if (bSmafType == AV_MMF_SMAF_TYPE_MA1)
psTrack->dStopTick = dPast + dGate;
else
}
sdTemp = _mmf_GetFlex2L(&pbBuf[dIndex], (dSize - dIndex), &dFlexSize);
- if (sdTemp < 0)
- {
+ if (sdTemp < 0) {
return AV_MMF_ERR_CHUNK;
}
dPast += sdTemp;
- if (dPast >= AV_MMF_PLAY_TIME_MAX)
- {
+ if (dPast >= AV_MMF_PLAY_TIME_MAX) {
return AV_MMF_ERR_LLENGTH;
}
dGate -= sdTemp;
dIndex += dFlexSize;
- if (dSize < dIndex + 2)
- {
+ if (dSize < dIndex + 2) {
return AV_MMF_ERR_CHUNK;
}
- switch (pbBuf[dIndex])
- {
- case 0x00 :
- if ((pbBuf[dIndex + 1] & 0x30) != 0x30)
- dIndex += 2;
- else
- dIndex += 3;
- break;
- case 0xFF :
- switch (pbBuf[dIndex + 1])
- {
- case 0x00 :
- dIndex += 2;
+ switch (pbBuf[dIndex]) {
+ case 0x00:
+ if ((pbBuf[dIndex + 1] & 0x30) != 0x30)
+ dIndex += 2;
+ else
+ dIndex += 3;
break;
- case 0xF0 :
- if (dSize < dIndex + 3)
- {
- return AV_MMF_ERR_CHUNK;
- }
- dIndex += (pbBuf[dIndex + 2] + 3);
- if (dSize < dIndex) {
- return AV_MMF_ERR_CHUNK;
+ case 0xFF:
+ switch (pbBuf[dIndex + 1]) {
+ case 0x00:
+ dIndex += 2;
+ break;
+ case 0xF0:
+ if (dSize < dIndex + 3) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ dIndex += (pbBuf[dIndex + 2] + 3);
+ if (dSize < dIndex) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ if (pbBuf[dIndex - 1] != 0xF7) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ break;
+ default:
+ return AV_MMF_ERR_CHUNK;
}
- if (pbBuf[dIndex - 1] != 0xF7)
- {
+ break;
+ default:
+ sdTemp = _mmf_GetFlex2L(&pbBuf[dIndex + 1], (dSize - dIndex - 1), &dFlexSize);
+ if (sdTemp < 0) {
return AV_MMF_ERR_CHUNK;
}
+ if (dGate < (unsigned int)sdTemp)
+ dGate = (unsigned int)sdTemp;
+ dIndex += (1 + dFlexSize);
break;
- default :
- return AV_MMF_ERR_CHUNK;
- }
- break;
- default :
- sdTemp = _mmf_GetFlex2L(&pbBuf[dIndex+1], (dSize - dIndex- 1), &dFlexSize);
- if (sdTemp < 0)
- {
- return AV_MMF_ERR_CHUNK;
- }
- if (dGate < (unsigned int)sdTemp)
- dGate = (unsigned int)sdTemp;
- dIndex += (1 + dFlexSize);
- break;
}
if (dSize < dIndex) {
return AV_MMF_ERR_CHUNK;
}
- if (psTrack->dStartTick == AV_MMF_STSP_TIME_NULL)
- {
- if (psTrack->dStartPoint != AV_MMF_STSP_OFFSET_NULL)
- {
+ if (psTrack->dStartTick == AV_MMF_STSP_TIME_NULL) {
+ if (psTrack->dStartPoint != AV_MMF_STSP_OFFSET_NULL) {
return AV_MMF_ERR_CHUNK;
}
psTrack->dStartTick = 0;
}
-/* check start/stop point potision */
- if (psTrack->dStopTick == AV_MMF_STSP_TIME_NULL)
- {
- if ((psTrack->dStopPoint != AV_MMF_STSP_OFFSET_NULL) && (psTrack->dStopPoint != dIndex))
- {
+ /* check start/stop point potision */
+ if (psTrack->dStopTick == AV_MMF_STSP_TIME_NULL) {
+ if ((psTrack->dStopPoint != AV_MMF_STSP_OFFSET_NULL) && (psTrack->dStopPoint != dIndex)) {
return AV_MMF_ERR_CHUNK;
}
if (bSmafType == AV_MMF_SMAF_TYPE_MA1)
psTrack->dStopTick = dPast;
}
-/* calculate playback time of this track */
+ /* calculate playback time of this track */
psTrack->dPlayTime = psTrack->dStopTick - psTrack->dStartTick;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Play time: %ld\n", psTrack->dPlayTime);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Play time: %ld\n", psTrack->dPlayTime);
+#endif
return AV_MMF_FUNC_SUCCESS;
}
int sdResult;
unsigned char i, fbVoice;
-/* delete track information of MA-3/5 */
- psLoad->sTrack_Info[5].pbMtr = NULL;
- psLoad->sTrack_Info[5].dMtrSize = 0;
- psLoad->sTrack_Info[6].pbMtr = NULL;
- psLoad->sTrack_Info[6].dMtrSize = 0;
+ /* delete track information of MA-3/5 */
+ psLoad->sTrack_Info[5].pbMtr = NULL;
+ psLoad->sTrack_Info[5].dMtrSize = 0;
+ psLoad->sTrack_Info[6].pbMtr = NULL;
+ psLoad->sTrack_Info[6].dMtrSize = 0;
-/* fix SMAF Type */
+ /* fix SMAF Type */
psLoad->dSmafType = AV_MMF_SMAF_TYPE_MA1;
- for (i = 1; i < 5; i++)
- {
- if (psLoad->sTrack_Info[i].pbMtr != NULL)
- {
+ for (i = 1; i < 5; i++) {
+ if (psLoad->sTrack_Info[i].pbMtr != NULL) {
psLoad->dSmafType = AV_MMF_SMAF_TYPE_MA2;
break;
}
if (psLoad->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr != NULL)
psLoad->dSmafType = AV_MMF_SMAF_TYPE_MA2;
- if (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA1)
- { /* MA-1 */
- if (psLoad->sTrack_Info[0].pbMtr == NULL)
- {
+ if (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA1) {
+ /* MA-1 */
+ if (psLoad->sTrack_Info[0].pbMtr == NULL) {
return AV_MMF_ERR_SLENGTH;
}
psTrack = &(psLoad->sTrack_Info[0]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2)
- {
+ if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA1);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
_mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
sdResult = _mmf_STSPCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
sdResult = _mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA1);
- if (sdResult != AV_MMF_MA2_VOICE_FOUND)
- {
+ if (sdResult != AV_MMF_MA2_VOICE_FOUND) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA1);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
return AV_MMF_FUNC_SUCCESS;
- }
- else
- { /* MA-2 */
+ } else {
+ /* MA-2 */
psLoad->sTrack_Info[0].pbMtr = NULL;
psLoad->sTrack_Info[0].dMtrSize = 0;
- for (i = 1; i < 5; i++)
- {
+ for (i = 1; i < 5; i++) {
psTrack = &(psLoad->sTrack_Info[i]);
if (psTrack->pbMtr == NULL)
continue;
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2)
- {
+ if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA2);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
_mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
sdResult = _mmf_STSPCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
sdResult = _mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
}
- if (psLoad->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr != NULL)
- {
+ if (psLoad->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr != NULL) {
psTrack = &(psLoad->sTrack_Info[AV_MMF_ATR_TRACK_NO]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2)
- {
+ if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_ATRCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
_mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
sdResult = _mmf_STSPCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
sdResult = _mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dTimeBase = psTrack->dTimeBase;
}
-/* totaling of track information */
- for (i = 1; i < AV_MMF_MAX_TRACK_NUM; i++)
- {
+ /* totaling of track information */
+ for (i = 1; i < AV_MMF_MAX_TRACK_NUM; i++) {
psTrack = &(psLoad->sTrack_Info[i]);
if (psTrack->pbMtr == NULL)
continue;
if (psLoad->dPlayTime < psTrack->dPlayTime)
psLoad->dPlayTime = psTrack->dPlayTime;
- if (psLoad->dTimeBase != psTrack->dTimeBase)
- {
+ if (psLoad->dTimeBase != psTrack->dTimeBase) {
return AV_MMF_ERR_CHUNK;
}
- if (psLoad->dStartTime != psTrack->dStartTick)
- {
+ if (psLoad->dStartTime != psTrack->dStartTick) {
return AV_MMF_ERR_CHUNK;
}
if (_mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2) == AV_MMF_FUNC_SUCCESS)
}
fbVoice = AV_MMF_MA2_VOICE_FOUND;
- for (i = 1; i < 5; i++)
- {
+ for (i = 1; i < 5; i++) {
psTrack = &(psLoad->sTrack_Info[i]);
if (psTrack->pbMtr == NULL)
continue;
- if (_mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2) == AV_MMF_MA2_VOICE_FOUND)
- {
+ if (_mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2) == AV_MMF_MA2_VOICE_FOUND) {
fbVoice = AV_MMF_MA2_VOICE_FOUND;
break;
- }
- else
+ } else
fbVoice = AV_MMF_MA2_VOICE_NOTFOUND;
}
- if (fbVoice == AV_MMF_MA2_VOICE_NOTFOUND)
- {
+ if (fbVoice == AV_MMF_MA2_VOICE_NOTFOUND) {
return AV_MMF_ERR_CHUNK;
}
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Play time: %ld\n", psLoad->dPlayTime);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Play time: %ld\n", psLoad->dPlayTime);
+#endif
return AV_MMF_FUNC_SUCCESS;
}
static unsigned char
_mmf_GetByte3L(PHUFFMANINFO psHuf)
{
- psHuf->dReadSize ++;
- if (psHuf->dReadSize > psHuf->dMtsqSize)
- {
+ psHuf->dReadSize++;
+ if (psHuf->dReadSize > psHuf->dMtsqSize) {
return 0;
}
return *(psHuf->psBuffer++);
* < 0 error code
********************************************************************************/
static int
-_mmf_GetFlex3L(PLOADINFO psLoad, unsigned int* pdRead)
+_mmf_GetFlex3L(PLOADINFO psLoad, unsigned int *pdRead)
{
unsigned int dTemp, dRead;
unsigned char bTemp;
dRead = 1;
- bTemp = psLoad->pfnGetByte( &(psLoad->sHuffman_Info) );
+ bTemp = psLoad->pfnGetByte(&(psLoad->sHuffman_Info));
dTemp = (unsigned int)(bTemp & 0x7F);
- while (bTemp & 0x80)
- {
+ while (bTemp & 0x80) {
if (dRead >= 4)
return AV_MMF_FUNC_ERROR;
- dRead ++;
- bTemp = psLoad->pfnGetByte( &(psLoad->sHuffman_Info) );
+ dRead++;
+ bTemp = psLoad->pfnGetByte(&(psLoad->sHuffman_Info));
dTemp = (dTemp << 7) + (unsigned int)(bTemp & 0x7F);
}
if (dTemp >= AV_MMF_PLAY_TIME_MAX)
int sdTemp;
unsigned char bTemp;
- if (bSmafType == AV_MMF_SMAF_TYPE_MA3)
- { /* MA-3 */
+ if (bSmafType == AV_MMF_SMAF_TYPE_MA3) {
+ /* MA-3 */
psTrk = &(psLoad->sTrack_Info[5]);
dStartTick = AV_MMF_STSP_TIME_NULL;
dStopTick = AV_MMF_STSP_TIME_NULL;
- }
- else
- { /* MA-5 */
+ } else {
+ /* MA-5 */
psTrk = &(psLoad->sTrack_Info[6]);
dStartTick = psTrk->dStartTick;
dStopTick = psTrk->dStopTick;
psPhr = &(psLoad->sPhrase_Info[0]);
psHuf = &(psLoad->sHuffman_Info);
- fdPhrase= 0;
+ fdPhrase = 0;
dIndex = 0;
dPast = 0;
dGate = 0;
dSize = psHuf->dSeqSize;
- if (psHuf->dSeqSize == 0)
- {
+ if (psHuf->dSeqSize == 0) {
return AV_MMF_ERR_SLENGTH;
}
- for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++)
- {
+ for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
if (psPhr[i].dStartPoint != AV_MMF_STSP_OFFSET_NULL)
fdPhrase = 1;
}
-/* scanning sequence data to EOS or stop point */
- while (dSize >= dIndex)
- {
+ /* scanning sequence data to EOS or stop point */
+ while (dSize >= dIndex) {
if (psTrk->dStartPoint == dIndex)
psTrk->dStartTick = dPast;
if (psTrk->dStopPoint == dIndex) /* stop point */
psTrk->dStopTick = dPast;
- if (fdPhrase)
- {
- for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++)
- {
- if (psPhr[i].dStartPoint== dIndex)
+ if (fdPhrase) {
+ for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
+ if (psPhr[i].dStartPoint == dIndex)
psPhr[i].dStartTick = dPast;
if (psPhr[i].dStopPoint == dIndex)
psPhr[i].dStopTick = dPast;
return AV_MMF_ERR_CHUNK;
}
dPast += (unsigned int)sdTemp;
- if (dPast >= AV_MMF_PLAY_TIME_MAX)
- {
+ if (dPast >= AV_MMF_PLAY_TIME_MAX) {
return AV_MMF_ERR_LLENGTH;
}
dIndex += dReadSize;
bTemp = psLoad->pfnGetByte(psHuf);
- dIndex ++;
-
- switch (bTemp & 0xF0)
- {
- case 0x90 :
- psLoad->pfnGetByte(psHuf); /*Note number*/
- dIndex ++;
- psLoad->pfnGetByte(psHuf); /*Key Velocity*/
- dIndex ++;
- sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
- dIndex += dReadSize;
- if ((unsigned int)sdTemp > dGate)
- dGate = sdTemp;
- break;
- case 0x80 :
- psLoad->pfnGetByte(psHuf); /*Note number*/
- dIndex ++;
- sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
- dIndex += dReadSize;
- if ((unsigned int)sdTemp > dGate)
- dGate = sdTemp;
- break;
- case 0xA0 :
- case 0xB0 :
- case 0xE0 :
- bTemp = psLoad->pfnGetByte(psHuf); /*B0: Conrol number, E0:Pitch Bend Change LSB*/
- dIndex ++;
- bTemp = psLoad->pfnGetByte(psHuf); /*B0: Conrol value, E0:Pitch Bend Change MSB*/
- dIndex ++;
- break;
- case 0xC0 :
- case 0xD0 :
- bTemp = psLoad->pfnGetByte(psHuf);
- dIndex ++;
- break;
- default :
- switch (bTemp)
- {
- case 0xF0 :
+ dIndex++;
+
+ switch (bTemp & 0xF0) {
+ case 0x90:
+ psLoad->pfnGetByte(psHuf); /*Note number*/
+ dIndex++;
+ psLoad->pfnGetByte(psHuf); /*Key Velocity*/
+ dIndex++;
sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
if (sdTemp < 0) {
return AV_MMF_ERR_CHUNK;
}
- for (i = 0; i < (unsigned int)sdTemp; i++)
- bTemp = psLoad->pfnGetByte(psHuf);
- if (bTemp != 0xF7) {
+ dIndex += dReadSize;
+ if ((unsigned int)sdTemp > dGate)
+ dGate = sdTemp;
+ break;
+ case 0x80:
+ psLoad->pfnGetByte(psHuf); /*Note number*/
+ dIndex++;
+ sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
+ if (sdTemp < 0) {
return AV_MMF_ERR_CHUNK;
}
- dIndex += (unsigned int)sdTemp + dReadSize;
+ dIndex += dReadSize;
+ if ((unsigned int)sdTemp > dGate)
+ dGate = sdTemp;
+ break;
+ case 0xA0:
+ case 0xB0:
+ case 0xE0:
+ bTemp = psLoad->pfnGetByte(psHuf); /*B0: Conrol number, E0:Pitch Bend Change LSB*/
+ dIndex++;
+ bTemp = psLoad->pfnGetByte(psHuf); /*B0: Conrol value, E0:Pitch Bend Change MSB*/
+ dIndex++;
break;
- case 0xFF :
+ case 0xC0:
+ case 0xD0:
bTemp = psLoad->pfnGetByte(psHuf);
- dIndex ++;
- switch (bTemp)
- {
- case 0x00 :
- break;
- case 0x2F :
- bTemp = psLoad->pfnGetByte(psHuf);
- dIndex ++;
- if (bTemp != 0x00)
- {
+ dIndex++;
+ break;
+ default:
+ switch (bTemp) {
+ case 0xF0:
+ sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
+ if (sdTemp < 0) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ for (i = 0; i < (unsigned int)sdTemp; i++)
+ bTemp = psLoad->pfnGetByte(psHuf);
+ if (bTemp != 0xF7) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ dIndex += (unsigned int)sdTemp + dReadSize;
+ break;
+ case 0xFF:
+ bTemp = psLoad->pfnGetByte(psHuf);
+ dIndex++;
+ switch (bTemp) {
+ case 0x00:
+ break;
+ case 0x2F:
+ bTemp = psLoad->pfnGetByte(psHuf);
+ dIndex++;
+ if (bTemp != 0x00) {
+ return AV_MMF_ERR_CHUNK;
+ }
+ dGate = 0;
+ psTrk->dStopTick = dPast;
+ dIndex = dSize;
+ break;
+ default:
+ return AV_MMF_ERR_CHUNK;
+ }
+ break;
+ default:
return AV_MMF_ERR_CHUNK;
- }
- dGate = 0;
- psTrk->dStopTick = dPast;
- dIndex = dSize;
- break;
- default :
- return AV_MMF_ERR_CHUNK;
}
break;
- default :
- return AV_MMF_ERR_CHUNK;
- }
- break;
}
- if ((dSize < dIndex) || (psHuf->dReadSize > psHuf->dMtsqSize))
- {
+ if ((dSize < dIndex) || (psHuf->dReadSize > psHuf->dMtsqSize)) {
return AV_MMF_ERR_CHUNK;
}
}
- if (bSmafType == AV_MMF_SMAF_TYPE_MA3)
- { /* MA-3 */
-/* check start point */
- if (psTrk->dStartTick == AV_MMF_STSP_TIME_NULL)
- {
- if (psTrk->dStartPoint != AV_MMF_STSP_OFFSET_NULL)
- {
+ if (bSmafType == AV_MMF_SMAF_TYPE_MA3) {
+ /* MA-3 */
+ /* check start point */
+ if (psTrk->dStartTick == AV_MMF_STSP_TIME_NULL) {
+ if (psTrk->dStartPoint != AV_MMF_STSP_OFFSET_NULL) {
return AV_MMF_ERR_CHUNK;
}
psTrk->dStartPoint = 0;
psTrk->dStartTick = 0;
}
-/* check stop point */
- if (psTrk->dStopTick == AV_MMF_STSP_TIME_NULL)
- {
- if (psTrk->dStopPoint != AV_MMF_STSP_OFFSET_NULL)
- {
+ /* check stop point */
+ if (psTrk->dStopTick == AV_MMF_STSP_TIME_NULL) {
+ if (psTrk->dStopPoint != AV_MMF_STSP_OFFSET_NULL) {
return AV_MMF_ERR_CHUNK;
}
psTrk->dStopPoint = dSize;
psTrk->dStopTick = dPast + dGate;
}
-/* adjust phrase information */
- for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++)
- {
+ /* adjust phrase information */
+ for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
if (psPhr[i].dStartPoint <= psTrk->dStartPoint)
psPhr[i].dStartTick = psTrk->dStartTick;
if (psPhr[i].dStopPoint >= psTrk->dStopPoint)
if (psPhr[i].dStopPoint <= psTrk->dStartPoint)
psPhr[i].dStopTick = AV_MMF_STSP_TIME_NULL;
}
- }
- else
- { /* MA-5 */
-/* check stop point */
- if (dStopTick > dPast)
- {
+ } else {
+ /* MA-5 */
+ /* check stop point */
+ if (dStopTick > dPast) {
return AV_MMF_ERR_CHUNK;
}
psTrk->dStartTick = dStartTick;
psTrk->dStopTick = dStopTick;
}
-/* calculate playback time of this track */
+ /* calculate playback time of this track */
psTrk->dPlayTime = psTrk->dStopTick - psTrk->dStartTick;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Play time: %ld\n", psTrk->dPlayTime);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Play time: %ld\n", psTrk->dPlayTime);
+#endif
return AV_MMF_FUNC_SUCCESS;
}
{
char czero = 0;
- if (--psHuf->sbBitC < czero)
- {
+ if (--psHuf->sbBitC < czero) {
if (psHuf->dReadSize >= psHuf->dMtsqSize)
return 0;
psHuf->sbBitC = 7;
psHuf->bByte = *(psHuf->psBuffer++);
- psHuf->dReadSize ++;
+ psHuf->dReadSize++;
}
return (unsigned char)(psHuf->bByte & g_abBitMaskTable1[(int)(psHuf->sbBitC)]);
}
bData1 = psHuf->bByte;
bData2 = *(psHuf->psBuffer++);
psHuf->bByte = bData2;
- psHuf->dReadSize ++;
+ psHuf->dReadSize++;
wTemp = (unsigned short)((((unsigned short)bData1) << 8) + ((unsigned short)bData2));
return (unsigned char)((wTemp & g_awBitMaskTable2[(int)(psHuf->sbBitC)]) >> psHuf->sbBitC);
}
* 0 error
********************************************************************************/
static int
-_mmf_DecodeTree( PHUFFMANINFO psHuf)
+_mmf_DecodeTree(PHUFFMANINFO psHuf)
{
unsigned int dNode, dEmpty, dIndex, i;
short *pswLeft, *pswRight, *pswPNode;
unsigned char bTemp;
- if (_mmf_DecodeGetbitL(psHuf))
- {
+ if (_mmf_DecodeGetbitL(psHuf)) {
if (psHuf->dReadSize >= psHuf->dMtsqSize)
return AV_MMF_HUFFMAN_TREE_FAILURE;
pswLeft = &(psHuf->swLeft[256]);
- pswRight= &(psHuf->swRight[256]);
- pswPNode= &(psHuf->swRight[0]);
- for (i = 0; i < 256; i++)
- {
+ pswRight = &(psHuf->swRight[256]);
+ pswPNode = &(psHuf->swRight[0]);
+ for (i = 0; i < 256; i++) {
pswLeft[i] = -1;
pswRight[i] = -1;
pswPNode[i] = 0;
dNode = 2;
dEmpty = 1;
dIndex = 0;
- }
- else
+ } else
return AV_MMF_HUFFMAN_TREE_FAILURE;
- while (dNode != 0)
- {
+ while (dNode != 0) {
if ((dEmpty >= 256) || (dNode >= 257))
return AV_MMF_HUFFMAN_TREE_FAILURE;
if (psHuf->dReadSize >= psHuf->dMtsqSize)
return AV_MMF_HUFFMAN_TREE_FAILURE;
- if (bTemp)
- {
- dNode ++;
+ if (bTemp) {
+ dNode++;
if (pswLeft[dIndex] == -1)
pswLeft[dIndex] = (short)(dEmpty + 256);
else
- pswRight[dIndex]= (short)(dEmpty + 256);
+ pswRight[dIndex] = (short)(dEmpty + 256);
pswPNode[dEmpty] = (short)dIndex;
dIndex = dEmpty;
- dEmpty ++;
- }
- else
- {
- dNode --;
+ dEmpty++;
+ } else {
+ dNode--;
bTemp = _mmf_DecodeGetbits(psHuf);
if (psHuf->dReadSize >= psHuf->dMtsqSize)
return AV_MMF_HUFFMAN_TREE_FAILURE;
if (pswLeft[dIndex] == -1)
pswLeft[dIndex] = (short)bTemp;
- else
- {
- pswRight[dIndex]= (short)bTemp;
+ else {
+ pswRight[dIndex] = (short)bTemp;
while ((pswRight[dIndex] != -1) && (dIndex != 0))
dIndex = (unsigned int)pswPNode[dIndex];
}
}
}
- for (i = 0; i < 256; i++)
- {
+ for (i = 0; i < 256; i++) {
if (pswLeft[i] == -1)
pswLeft[i] = 0;
if (pswRight[i] == -1)
{
unsigned int dSeqSize;
- if (psHuf->dMtsqSize <= 5)
- {
+ if (psHuf->dMtsqSize <= 5) {
return AV_MMF_HUFFMAN_TREE_FAILURE;
}
* 0 error code
********************************************************************************/
static unsigned char
-_mmf_DecodeByte3L (PHUFFMANINFO psHuf)
+_mmf_DecodeByte3L(PHUFFMANINFO psHuf)
{
unsigned int bData, bIndex;
char czero = 0;
bIndex = 256;
- while (bIndex >= 256)
- {
- if (--psHuf->sbBitC < czero)
- {
- psHuf->dReadSize ++;
+ while (bIndex >= 256) {
+ if (--psHuf->sbBitC < czero) {
+ psHuf->dReadSize++;
if (psHuf->dReadSize > psHuf->dMtsqSize)
return 0;
psHuf->sbBitC = 7;
PTRACKINFO psTrack;
int sdResult;
- if (psLoad->sTrack_Info[5].pbMtr == NULL)
- {
+ if (psLoad->sTrack_Info[5].pbMtr == NULL) {
return AV_MMF_ERR_SLENGTH;
}
psTrack = &(psLoad->sTrack_Info[5]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE3)
- {
+ if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE3) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA3);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
_mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
psLoad->sHuffman_Info.psBuffer = psTrack->pbMtsq;
psLoad->sHuffman_Info.dMtsqSize = psTrack->dMtsqSize;
-/* Initialize Huffman information structure */
- if (psTrack->pbMtr[0] == 0x01)
- { /* Compressed Foramt */
- psLoad->sHuffman_Info.dSeqSize = _mmf_DecodeInit( &(psLoad->sHuffman_Info) );
- if (psLoad->sHuffman_Info.dSeqSize == AV_MMF_HUFFMAN_TREE_FAILURE)
- {
+ /* Initialize Huffman information structure */
+ if (psTrack->pbMtr[0] == 0x01) {
+ /* Compressed Foramt */
+ psLoad->sHuffman_Info.dSeqSize = _mmf_DecodeInit(&(psLoad->sHuffman_Info));
+ if (psLoad->sHuffman_Info.dSeqSize == AV_MMF_HUFFMAN_TREE_FAILURE) {
return AV_MMF_ERR_CHUNK;
}
psLoad->pfnGetByte = _mmf_DecodeByte3L;
psLoad->sHuffman_Info.psFBuf = psLoad->sHuffman_Info.psBuffer;
psLoad->sHuffman_Info.sbFBit = psLoad->sHuffman_Info.sbBitC;
psLoad->sHuffman_Info.bFByte = psLoad->sHuffman_Info.bByte;
- }
- else
- { /* No Compressed Foramt */
+ } else {
+ /* No Compressed Foramt */
psLoad->pfnGetByte = _mmf_GetByte3L;
psLoad->sHuffman_Info.dSeqSize = psTrack->dMtsqSize;
psLoad->sHuffman_Info.dReadSize = 0;
sdResult = _mmf_STSPCheck(psTrack);
psTrack->dMtsqSize = psLoad->sHuffman_Info.dMtsqSize;
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
sdResult = _mmf_SeqDataCheck3(psLoad, AV_MMF_SMAF_TYPE_MA3);
- if (sdResult != AV_MMF_FUNC_SUCCESS)
- {
+ if (sdResult != AV_MMF_FUNC_SUCCESS) {
return sdResult;
}
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Play time: %ld\n", psLoad->dPlayTime);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Play time: %ld\n", psLoad->dPlayTime);
+#endif
return AV_MMF_FUNC_SUCCESS;
}
pbM5p = NULL;
dMSize = 0;
-/* search Pro5 Chunk */
- while (dOSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE))
- {
+ /* search Pro5 Chunk */
+ while (dOSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
sdChunkSize = _mmf_MalibNextChunk(&pbOpda[dIndex], (dOSize - dIndex),
- AVMALIB_CHUNK_PHASE_OPDASUB, &dChunkID, &dChunkNo);
+ AVMALIB_CHUNK_PHASE_OPDASUB, &dChunkID, &dChunkNo);
if (sdChunkSize < AVMASMW_SUCCESS) return AVMASMW_ERROR;
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
- if ((dChunkID == AVMALIB_CHUNKCODE_M5P) && (dChunkNo == 0x05))
- {
+ if ((dChunkID == AVMALIB_CHUNKCODE_M5P) && (dChunkNo == 0x05)) {
pbM5p = &pbOpda[dIndex];
dMSize = (unsigned int)sdChunkSize;
break;
if (psTrk->dStartTick >= psTrk->dStopTick) return AVMASMW_ERROR;
- for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i ++)
- {
+ for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
if (dMSize < (dIndex + 8)) break;
- if (dPhraseFlag & (0x80000000 >> i))
- {
+ if (dPhraseFlag & (0x80000000 >> i)) {
psPhr[i].dStartTick = _mmf_Get4Byte(&pbM5p[dIndex]);
psPhr[i].dStopTick = _mmf_Get4Byte(&pbM5p[dIndex + 4]);
- if (psPhr[i].dStartTick >= psPhr[i].dStopTick)
- {
+ if (psPhr[i].dStartTick >= psPhr[i].dStopTick) {
psPhr[i].dStartTick = AV_MMF_STSP_TIME_NULL;
psPhr[i].dStopTick = AV_MMF_STSP_TIME_NULL;
}
PTRACKINFO psTrack;
int sdResult;
- if (psLoad->sTrack_Info[6].pbMtr == NULL)
- {
+ if (psLoad->sTrack_Info[6].pbMtr == NULL) {
return AV_MMF_ERR_SLENGTH;
}
psTrack = &(psLoad->sTrack_Info[6]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE3)
- {
+ if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE3) {
return AV_MMF_ERR_CHUNK;
}
sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA5);
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Play time: %ld\n", psLoad->dPlayTime);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Play time: %ld\n", psLoad->dPlayTime);
+#endif
return AV_MMF_FUNC_SUCCESS;
}
static void
_mmf_GetHvData(PLOADINFO psLoad, unsigned char bCType)
{
- unsigned char* pbHvData;
+ unsigned char *pbHvData;
unsigned int dHvDataSize;
- unsigned char* pbVoice;
- unsigned char* pbScript;
- unsigned char* pbSetup;
+ unsigned char *pbVoice;
+ unsigned char *pbScript;
+ unsigned char *pbSetup;
unsigned int dVoiceSize, dScriptSize, dSetupSize, dIndex;
unsigned char bHvCh;
unsigned short wTag, wSize;
unsigned int dChunkID, dChunkNo;
int sdChunkSize;
- if ((psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA1) ||(psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA2))
+ if ((psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA1) || (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA2))
return ;
if ((bCType & 0x0F) == 0x08)
return ;
- if (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA3)
- {
+ if (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA3) {
pbHvData = psLoad->sTrack_Info[5].pbMthv;
dHvDataSize = psLoad->sTrack_Info[5].dMthvSize;
- }
- else
- {
+ } else {
pbHvData = psLoad->sTrack_Info[6].pbMthv;
dHvDataSize = psLoad->sTrack_Info[6].dMthvSize;
}
bHvCh = AV_MMF_HV_CHANNEL_NULL;
dIndex = 0;
- while (dHvDataSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE))
- {
+ while (dHvDataSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
sdChunkSize = _mmf_MalibNextChunk(&(pbHvData[dIndex]), (dHvDataSize - dIndex),
- AVMALIB_CHUNK_PHASE_MTHVSUB, &dChunkID, &dChunkNo);
+ AVMALIB_CHUNK_PHASE_MTHVSUB, &dChunkID, &dChunkNo);
if (sdChunkSize < 0) return ;
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
- switch (dChunkID)
- {
- case AVMALIB_CHUNKCODE_MHVS :
- pbSetup = &(pbHvData[dIndex]);
- dSetupSize = (unsigned int)sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_HVP :
- if (dChunkNo != 0) break;
- pbVoice = &(pbHvData[dIndex - AV_MMF_CHUNK_HEADER_SIZE]);
- dVoiceSize = (unsigned int)(sdChunkSize + AV_MMF_CHUNK_HEADER_SIZE);
- break;
- case AVMALIB_CHUNKCODE_MHSC :
- pbScript = &(pbHvData[dIndex]);
- dScriptSize = (unsigned int)sdChunkSize;
- break;
- default :
- break;
+ switch (dChunkID) {
+ case AVMALIB_CHUNKCODE_MHVS:
+ pbSetup = &(pbHvData[dIndex]);
+ dSetupSize = (unsigned int)sdChunkSize;
+ break;
+ case AVMALIB_CHUNKCODE_HVP:
+ if (dChunkNo != 0) break;
+ pbVoice = &(pbHvData[dIndex - AV_MMF_CHUNK_HEADER_SIZE]);
+ dVoiceSize = (unsigned int)(sdChunkSize + AV_MMF_CHUNK_HEADER_SIZE);
+ break;
+ case AVMALIB_CHUNKCODE_MHSC:
+ pbScript = &(pbHvData[dIndex]);
+ dScriptSize = (unsigned int)sdChunkSize;
+ break;
+ default:
+ break;
}
dIndex += sdChunkSize;
}
dIndex = 0;
- while (dSetupSize >= dIndex + 4 )
- {
- wTag = (unsigned short)(((unsigned short)(pbSetup[dIndex ]) << 8) + pbSetup[dIndex + 1]);
+ while (dSetupSize >= dIndex + 4) {
+ wTag = (unsigned short)(((unsigned short)(pbSetup[dIndex]) << 8) + pbSetup[dIndex + 1]);
wSize = (unsigned short)(((unsigned short)(pbSetup[dIndex + 2]) << 8) + pbSetup[dIndex + 3]);
dIndex += 4;
if (dSetupSize < (dIndex + wSize)) return ;
* unsigned char success(read data)
********************************************************************************/
static unsigned short
-_mmf_MalibMakeCRC(unsigned int dSize, unsigned char* pbData)
+_mmf_MalibMakeCRC(unsigned int dSize, unsigned char *pbData)
{
unsigned short wRes;
unsigned char bData;
wRes = 0xFFFFU;
- while ( --dSize >= 2 )
- {
+ while (--dSize >= 2) {
bData = *pbData++;
wRes = (unsigned short)((wRes << 8) ^ g_crc_tbl[(unsigned char)(wRes >> 8) ^ bData]);
}
* < 0 error code
********************************************************************************/
static int
-_mmf_MALoad( unsigned char* pbFile, unsigned int dFSize)
+_mmf_MALoad(unsigned char *pbFile, unsigned int dFSize)
{
PLOADINFO psLoad_Info;
unsigned int bNo = 0;
unsigned int dChunkID = 0, dChunkNo = 0;
- unsigned char* pbBuf = NULL;
+ unsigned char *pbBuf = NULL;
unsigned int dSize = 0, dIndex = 0;
int sdChunkSize = 0, sdResult = 0;
unsigned int dCalcCrc = 0, dFileCrc = 0;
pbBuf = pbFile;
dSize = dFSize;
psLoad_Info = &(g_sSmaf_Info.sLoad_Info[bNo]);
- _mmf_CheckInitial( psLoad_Info );
+ _mmf_CheckInitial(psLoad_Info);
-/* check File Chunk(ID/Size) */
+ /* check File Chunk(ID/Size) */
sdChunkSize = _mmf_MalibNextChunk(pbBuf, dSize, AVMALIB_CHUNK_PHASE_MMMD,
- &dChunkID, &dChunkNo);
- if ((sdChunkSize < 0) || (dChunkID != AVMALIB_CHUNKCODE_MMMD))
- {
+ &dChunkID, &dChunkNo);
+ if ((sdChunkSize < 0) || (dChunkID != AVMALIB_CHUNKCODE_MMMD)) {
return AV_MMF_ERR_FILE;
}
dSize = (unsigned int)(sdChunkSize + AV_MMF_CHUNK_HEADER_SIZE);
}
-/* check Contents Info Chunk */
+ /* check Contents Info Chunk */
dIndex = AV_MMF_CHUNK_HEADER_SIZE;
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize-dIndex),
- AVMALIB_CHUNK_PHASE_CNTI, &dChunkID, &dChunkNo);
- if ((sdChunkSize < 5) || (dChunkID != AVMALIB_CHUNKCODE_CNTI))
- {
+ sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex),
+ AVMALIB_CHUNK_PHASE_CNTI, &dChunkID, &dChunkNo);
+ if ((sdChunkSize < 5) || (dChunkID != AVMALIB_CHUNKCODE_CNTI)) {
return AV_MMF_ERR_FILE;
}
-/* check Contents Class */
+ /* check Contents Class */
if ((pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_0) &&
- (pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_1) &&
- (pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_2) )
- {
+ (pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_1) &&
+ (pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_2)) {
return AV_MMF_ERR_CLASS;
}
-/* check Contents Type */
+ /* check Contents Type */
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
if (((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_0) ||
- ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_1) ||
- ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_2) )
- {
+ ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_1) ||
+ ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_2)) {
psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA2;
- }
- else if (((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_3) ||
- ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_4) ||
- ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_5) )
- {
- switch (pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0x0F)
- {
- case 0x00 :
- case 0x01 :
- psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA2;
- break;
- case 0x02 :
- case 0x03 :
- psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA3;
- break;
- case 0x04 :
- case 0x05 :
- case 0x06 :
- case 0x07 :
- case 0x08 :
- psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA5;
- break;
- default :
- return AV_MMF_ERR_TYPE;
+ } else if (((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_3) ||
+ ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_4) ||
+ ((pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0xF0) == AV_MMF_CONTENTS_TYPE_5)) {
+ switch (pbBuf[AV_MMF_POSITION_OF_CTYPE] & 0x0F) {
+ case 0x00:
+ case 0x01:
+ psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA2;
+ break;
+ case 0x02:
+ case 0x03:
+ psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA3;
+ break;
+ case 0x04:
+ case 0x05:
+ case 0x06:
+ case 0x07:
+ case 0x08:
+ psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA5;
+ break;
+ default:
+ return AV_MMF_ERR_TYPE;
}
- }
- else
- {
+ } else {
return AV_MMF_ERR_TYPE;
}
-/* get pointer & size of option information */
+ /* get pointer & size of option information */
psLoad_Info->sOption_Info.pbCnti = &pbBuf[dIndex];
psLoad_Info->sOption_Info.dCntiSize = (unsigned int)(sdChunkSize);
dIndex += sdChunkSize;
- if (pbBuf[AV_MMF_POSITION_OF_CTYPE] >= 0x30)
- {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize-dIndex),
- AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
- if ((sdChunkSize >= 12) && (dChunkID == AVMALIB_CHUNKCODE_OPDA))
- {
+ if (pbBuf[AV_MMF_POSITION_OF_CTYPE] >= 0x30) {
+ sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex),
+ AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
+ if ((sdChunkSize >= 12) && (dChunkID == AVMALIB_CHUNKCODE_OPDA)) {
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
psLoad_Info->sOption_Info.pbOpda = &pbBuf[dIndex];
psLoad_Info->sOption_Info.dOpdaSize = (unsigned int)sdChunkSize;
}
}
-/* get Track Chunk information */
- while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE + AV_MMF_FILE_CRC_SIZE))
- {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize-dIndex),
- AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0)
- {
- if (sdChunkSize == AVMALIB_CHUNK_ID_ERROR)
- {
+ /* get Track Chunk information */
+ while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE + AV_MMF_FILE_CRC_SIZE)) {
+ sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex),
+ AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
+ if (sdChunkSize < 0) {
+ if (sdChunkSize == AVMALIB_CHUNK_ID_ERROR) {
return AV_MMF_ERR_FILE;
- }
- else {
+ } else {
return AV_MMF_ERR_SIZE;
}
}
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
- switch (dChunkID)
- {
- case AVMALIB_CHUNKCODE_MTR :
- if (dChunkNo > 6)
+ switch (dChunkID) {
+ case AVMALIB_CHUNKCODE_MTR:
+ if (dChunkNo > 6)
+ break;
+ psLoad_Info->sTrack_Info[dChunkNo].pbMtr = &(pbBuf[dIndex]);
+ psLoad_Info->sTrack_Info[dChunkNo].dMtrSize = (unsigned int)sdChunkSize;
break;
- psLoad_Info->sTrack_Info[dChunkNo].pbMtr = &(pbBuf[dIndex]);
- psLoad_Info->sTrack_Info[dChunkNo].dMtrSize = (unsigned int)sdChunkSize;
- break;
- case AVMALIB_CHUNKCODE_ATR :
- if (dChunkNo != 0)
+ case AVMALIB_CHUNKCODE_ATR:
+ if (dChunkNo != 0)
+ break;
+ psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr = &(pbBuf[dIndex]);
+ psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].dMtrSize = (unsigned int)sdChunkSize;
+ break;
+ default:
break;
- psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr = &(pbBuf[dIndex]);
- psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].dMtrSize = (unsigned int)sdChunkSize;
- break;
- default :
- break;
}
dIndex += sdChunkSize;
}
-/* Error Check of Track Chunk */
- switch (psLoad_Info->dSmafType)
- {
- case AV_MMF_SMAF_TYPE_MA2 :
- sdResult = _mmf_TrackChunkCheck2(psLoad_Info);
- break;
- case AV_MMF_SMAF_TYPE_MA3 :
- sdResult = _mmf_TrackChunkCheck3(psLoad_Info);
- break;
- default :
- if (_mmf_CheckM5P(psLoad_Info)!= AV_MMF_FUNC_SUCCESS) return AV_MMF_ERR_CHUNK;
- sdResult = _mmf_TrackChunkCheck5(psLoad_Info);
- break;
+ /* Error Check of Track Chunk */
+ switch (psLoad_Info->dSmafType) {
+ case AV_MMF_SMAF_TYPE_MA2:
+ sdResult = _mmf_TrackChunkCheck2(psLoad_Info);
+ break;
+ case AV_MMF_SMAF_TYPE_MA3:
+ sdResult = _mmf_TrackChunkCheck3(psLoad_Info);
+ break;
+ default:
+ if (_mmf_CheckM5P(psLoad_Info) != AV_MMF_FUNC_SUCCESS) return AV_MMF_ERR_CHUNK;
+ sdResult = _mmf_TrackChunkCheck5(psLoad_Info);
+ break;
}
-/* check playback time */
+ /* check playback time */
if (sdResult != AV_MMF_FUNC_SUCCESS) return sdResult;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "SUM %ld\n", psLoad_Info->dPlayTime * psLoad_Info->dTimeBase);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("SUM %ld\n", psLoad_Info->dPlayTime * psLoad_Info->dTimeBase);
+#endif
- if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) <= AV_MMF_PLAY_TIME_MIN)
- {
+ if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) <= AV_MMF_PLAY_TIME_MIN) {
return AV_MMF_ERR_SLENGTH;
}
- if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) >= AV_MMF_PLAY_TIME_MAX)
- {
+ if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) >= AV_MMF_PLAY_TIME_MAX) {
return AV_MMF_ERR_LLENGTH;
}
- rVal = psLoad_Info->dPlayTime*psLoad_Info->dTimeBase;
+ rVal = psLoad_Info->dPlayTime * psLoad_Info->dTimeBase;
_mmf_GetHvData(psLoad_Info, pbBuf[AV_MMF_POSITION_OF_CTYPE]);
psLoad_Info->pbMmmd = pbBuf;
* < 0 error code
********************************************************************************/
static int
-_mmf_RenewalProfile(unsigned char* pbFile)
+_mmf_RenewalProfile(unsigned char *pbFile)
{
PLOADINFO psLoad;
POPTIONINFO psOptn;
psTrk = &(psLoad->sTrack_Info[5]);
psHuf = &(psLoad->sHuffman_Info);
-/* renew pointer offset to pointer */
+ /* renew pointer offset to pointer */
psLoad->pbMmmd = pbFile;
psLoad->dCrc = AV_MMF_CRC_NULL;
psTrk->pbMtsq = &(pbFile[(unsigned int)psTrk->pbMtsq]);
psTrk->pbMtsp = &(pbFile[(unsigned int)psTrk->pbMtsp]);
-/* Initialize Huffman information structure */
+ /* Initialize Huffman information structure */
psHuf->psBuffer = psTrk->pbMtsq;
psHuf->dMtsqSize = psTrk->dMtsqSize;
- if (psTrk->pbMtr[0] == 0x01)
- {
+ if (psTrk->pbMtr[0] == 0x01) {
psHuf->dSeqSize = _mmf_DecodeInit(psHuf);
- if (psHuf->dSeqSize == AV_MMF_HUFFMAN_TREE_FAILURE)
- {
+ if (psHuf->dSeqSize == AV_MMF_HUFFMAN_TREE_FAILURE) {
return AV_MMF_FUNC_ERROR;
}
}
static int
-_mmf_ParseSkipXmf2Mmf(unsigned char* pbFile, unsigned int dFSize)
+_mmf_ParseSkipXmf2Mmf(unsigned char *pbFile, unsigned int dFSize)
{
- unsigned int skipVal = 0, sizeOfpbFile= dFSize;
+ unsigned int skipVal = 0, sizeOfpbFile = dFSize;
char cmpXmfCMMD[5];
if (pbFile)
memcpy(cmpXmfCMMD, pbFile, 4);
- else
- {
- debug_error ( "NULL pointer!\n");
+ else {
+ debug_error("NULL pointer!\n");
return -1;
}
cmpXmfCMMD[4] = 0;
- if (strncmp(cmpXmfCMMD, "CMMD", 4) == 0)
- {
- while (1)
- {
- if (pbFile[skipVal] == 'M' && pbFile[skipVal+1] == 'M' && pbFile[skipVal+2] == 'M' && pbFile[skipVal+3] == 'D')
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "MMMD Header found!\n");
- #endif
+ if (strncmp(cmpXmfCMMD, "CMMD", 4) == 0) {
+ while (1) {
+ if (pbFile[skipVal] == 'M' && pbFile[skipVal + 1] == 'M' && pbFile[skipVal + 2] == 'M' && pbFile[skipVal + 3] == 'D') {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MMMD Header found!\n");
+#endif
break;
- }
- else
- {
+ } else {
skipVal++;
- if (skipVal >= sizeOfpbFile)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "MMMD Header is not found!\n");
- #endif
+ if (skipVal >= sizeOfpbFile) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MMMD Header is not found!\n");
+#endif
return -1;
}
}
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "File header is not started CMMD\n");
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("File header is not started CMMD\n");
+#endif
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "skip value: %d\n", skipVal);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("skip value: %d\n", skipVal);
+#endif
return skipVal;
}
static int
-mmf_file_mmf_get_duration (char *src, int is_xmf)
+mmf_file_mmf_get_duration(char *src, int is_xmf)
{
int readed = 0;
int xmf_skip_offset = 0;
#endif
/*open*/
- ret = mmfile_open (&fp, src, MMFILE_RDONLY);
- if (ret == MMFILE_UTIL_FAIL)
- {
- debug_error ( "open failed.\n");
+ ret = mmfile_open(&fp, src, MMFILE_RDONLY);
+ if (ret == MMFILE_UTIL_FAIL) {
+ debug_error("open failed.\n");
return -1;
}
/*get file size*/
- mmfile_seek (fp, 0L, MMFILE_SEEK_END);
- src_size = mmfile_tell (fp);
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_END);
+ src_size = mmfile_tell(fp);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (src_size <= 0) {
- debug_error ( "failed to get file size.\n");
+ debug_error("failed to get file size.\n");
ret_msec = -1;
goto _RELEASE_RESOURCE;
}
/*alloc work buffer*/
- buf = mmfile_malloc (src_size + 1);
+ buf = mmfile_malloc(src_size + 1);
/*read data*/
- if ((readed = mmfile_read (fp, buf, src_size) ) <= 0 ) {
- debug_error ( "read error. size = %d\n", readed);
+ if ((readed = mmfile_read(fp, buf, src_size)) <= 0) {
+ debug_error("read error. size = %d\n", readed);
ret_msec = -1;
goto _RELEASE_RESOURCE;
/*if XMF, get skip offset.*/
if (is_xmf) {
- xmf_skip_offset = _mmf_ParseSkipXmf2Mmf (buf, src_size);
+ xmf_skip_offset = _mmf_ParseSkipXmf2Mmf(buf, src_size);
if (xmf_skip_offset == -1) {
ret_msec = -1;
goto _RELEASE_RESOURCE;
if (g_sSmaf_Info.dStatus == AV_MMF_STATUS_SAT_PROFILE) {
load_info = &(g_sSmaf_Info.sLoad_Info[1]);
if (load_info->dMmmdSize <= src_size) {
- p_crc = &(buf[load_info->dMmmdSize -2+xmf_skip_offset]);
+ p_crc = &(buf[load_info->dMmmdSize - 2 + xmf_skip_offset]);
dCrc = (unsigned int)((((unsigned int)p_crc[0]) << 8) + (unsigned int)p_crc[1]);
} else {
dCrc = AV_MMF_CRC_NULL;
}
if (dCrc == load_info->dCrc) {
- if (_mmf_RenewalProfile (buf + xmf_skip_offset) == AV_MMF_FUNC_SUCCESS) {
+ if (_mmf_RenewalProfile(buf + xmf_skip_offset) == AV_MMF_FUNC_SUCCESS) {
g_sSmaf_Info.dStatus = AV_MMF_STATUS_LOADED;
ret_msec = -1;
goto _RELEASE_RESOURCE;
}
}
- ret_msec = _mmf_MALoad (buf + xmf_skip_offset, src_size);
+ ret_msec = _mmf_MALoad(buf + xmf_skip_offset, src_size);
_RELEASE_RESOURCE:
- mmfile_close (fp);
+ mmfile_close(fp);
- if (buf) mmfile_free (buf);
+ if (buf) mmfile_free(buf);
return ret_msec;
}
#define AV_MP3_FIND_SYNC_LEN 1024*30
-#undef MIN
+#undef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
-static const unsigned char mp3FrameMasking[4] = {0xFF,0xFE,0x0C,0x00};
+static const unsigned char mp3FrameMasking[4] = {0xFF, 0xFE, 0x0C, 0x00};
static unsigned char mp3FrameDataValid[4];
static const int mp3BitRateTable[2][3][16] = {
- { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
- {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
- {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} },
-
- { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
- {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
- {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} }
+ { {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
+ },
+
+ { {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
+ }
};
-static const int mp3SamRateTable[3][3] =
-{ {44100, 48000, 32000},
- {22050, 24000, 16000} ,
- {11025, 12000, 8000}
+static const int mp3SamRateTable[3][3] = {
+ {44100, 48000, 32000},
+ {22050, 24000, 16000},
+ {11025, 12000, 8000}
};
#define IS_VALID_FRAME_MP3(x) \
- ((((x)[0] & mp3FrameMasking[0]) == mp3FrameDataValid[0]) && \
- (((x)[1] & mp3FrameMasking[1]) == mp3FrameDataValid[1]) && \
- (((x)[2] & mp3FrameMasking[2]) == mp3FrameDataValid[2]) && \
- (((x)[3] & mp3FrameMasking[3]) == mp3FrameDataValid[3]))
+ ((((x)[0] & mp3FrameMasking[0]) == mp3FrameDataValid[0]) && \
+ (((x)[1] & mp3FrameMasking[1]) == mp3FrameDataValid[1]) && \
+ (((x)[2] & mp3FrameMasking[2]) == mp3FrameDataValid[2]) && \
+ (((x)[3] & mp3FrameMasking[3]) == mp3FrameDataValid[3]))
/* interface functions */
-int mmfile_format_read_stream_mp3 (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_mp3 (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_mp3 (MMFileFormatContext *formatContext);
-int mmfile_format_close_mp3 (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_mp3(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_mp3(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_mp3(MMFileFormatContext *formatContext);
+int mmfile_format_close_mp3(MMFileFormatContext *formatContext);
/* internal */
-static int mmf_file_mp3_get_infomation (char *src, AvFileContentInfo* pInfo );
+static int mmf_file_mp3_get_infomation(char *src, AvFileContentInfo *pInfo);
EXPORT_API
-int mmfile_format_open_mp3 (MMFileFormatContext *formatContext)
+int mmfile_format_open_mp3(MMFileFormatContext *formatContext)
{
- AvFileContentInfo *privateData = NULL;;
- int ret = 0;
+ AvFileContentInfo *privateData = NULL;;
+ int ret = 0;
#ifdef __MMFILE_TEST_MODE__
debug_fenter();
#endif
- if (NULL == formatContext)
- {
- debug_error("formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ if (NULL == formatContext) {
+ debug_error("formatContext is NULL\n");
+ return MMFILE_FORMAT_FAIL;
+ }
if (formatContext->pre_checked == 0) {
- ret = MMFileFormatIsValidMP3 (NULL, formatContext->uriFileName, 5);
- if ( ret == 0 )
- {
+ ret = MMFileFormatIsValidMP3(NULL, formatContext->uriFileName, 5);
+ if (ret == 0) {
debug_error("It is not mp3 file\n");
return MMFILE_FORMAT_FAIL;
}
}
- formatContext->ReadStream = mmfile_format_read_stream_mp3;
- formatContext->ReadFrame = mmfile_format_read_frame_mp3;
- formatContext->ReadTag = mmfile_format_read_tag_mp3;
- formatContext->Close = mmfile_format_close_mp3;
+ formatContext->ReadStream = mmfile_format_read_stream_mp3;
+ formatContext->ReadFrame = mmfile_format_read_frame_mp3;
+ formatContext->ReadTag = mmfile_format_read_tag_mp3;
+ formatContext->Close = mmfile_format_close_mp3;
- formatContext->videoTotalTrackNum = 0;
- formatContext->audioTotalTrackNum = 1;
+ formatContext->videoTotalTrackNum = 0;
+ formatContext->audioTotalTrackNum = 1;
- privateData = mmfile_malloc (sizeof (AvFileContentInfo));
- if (!privateData)
- {
- debug_error ("error: mmfile_malloc MP3 privateData\n");
- return MMFILE_FORMAT_FAIL;
- }
+ privateData = mmfile_malloc(sizeof(AvFileContentInfo));
+ if (!privateData) {
+ debug_error("error: mmfile_malloc MP3 privateData\n");
+ return MMFILE_FORMAT_FAIL;
+ }
- formatContext->privateFormatData = privateData;
+ formatContext->privateFormatData = privateData;
- ret = mmf_file_mp3_get_infomation (formatContext->uriFileName, privateData);
- if ( ret == -1 )
- {
- debug_error ("error: mmfile_format_read_stream_mp3\n");
- goto exception;
- }
+ ret = mmf_file_mp3_get_infomation(formatContext->uriFileName, privateData);
+ if (ret == -1) {
+ debug_error("error: mmfile_format_read_stream_mp3\n");
+ goto exception;
+ }
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
exception:
- mmfile_format_close_mp3 (formatContext);
- return MMFILE_FORMAT_FAIL;
+ mmfile_format_close_mp3(formatContext);
+ return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_read_stream_mp3 (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_mp3(MMFileFormatContext *formatContext)
{
- AvFileContentInfo *privateData = NULL;
+ AvFileContentInfo *privateData = NULL;
#ifdef __MMFILE_TEST_MODE__
debug_fenter();
#endif
- if (!formatContext || !formatContext->privateFormatData)
- {
- debug_error("formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- privateData = formatContext->privateFormatData;
-
- formatContext->duration = privateData->duration;
- formatContext->videoTotalTrackNum = 0;
- formatContext->audioTotalTrackNum = 1;
- formatContext->nbStreams = 1;
- formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc (sizeof (MMFileFormatStream));
- if (NULL == formatContext->streams[MMFILE_AUDIO_STREAM])
- {
- debug_error ("formatContext->streams[MMFILE_AUDIO_STREAM] is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- formatContext->streams[MMFILE_AUDIO_STREAM]->streamType = MMFILE_AUDIO_STREAM;
- formatContext->streams[MMFILE_AUDIO_STREAM]->codecId = MM_AUDIO_CODEC_MP3;
- formatContext->streams[MMFILE_AUDIO_STREAM]->bitRate = (privateData->bitRate*1000);
- formatContext->streams[MMFILE_AUDIO_STREAM]->framePerSec = (privateData->duration == 0 ? 0 : privateData->frameNum/privateData->duration);
- formatContext->streams[MMFILE_AUDIO_STREAM]->width = 0;
- formatContext->streams[MMFILE_AUDIO_STREAM]->height = 0;
- formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = privateData->channels;
- formatContext->streams[MMFILE_AUDIO_STREAM]->samplePerSec = privateData->sampleRate;
-
- return MMFILE_FORMAT_SUCCESS;
+ if (!formatContext || !formatContext->privateFormatData) {
+ debug_error("formatContext is NULL\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ privateData = formatContext->privateFormatData;
+
+ formatContext->duration = privateData->duration;
+ formatContext->videoTotalTrackNum = 0;
+ formatContext->audioTotalTrackNum = 1;
+ formatContext->nbStreams = 1;
+ formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc(sizeof(MMFileFormatStream));
+ if (NULL == formatContext->streams[MMFILE_AUDIO_STREAM]) {
+ debug_error("formatContext->streams[MMFILE_AUDIO_STREAM] is NULL\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ formatContext->streams[MMFILE_AUDIO_STREAM]->streamType = MMFILE_AUDIO_STREAM;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->codecId = MM_AUDIO_CODEC_MP3;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->bitRate = (privateData->bitRate * 1000);
+ formatContext->streams[MMFILE_AUDIO_STREAM]->framePerSec = (privateData->duration == 0 ? 0 : privateData->frameNum / privateData->duration);
+ formatContext->streams[MMFILE_AUDIO_STREAM]->width = 0;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->height = 0;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = privateData->channels;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->samplePerSec = privateData->sampleRate;
+
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_frame_mp3 (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_mp3(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
- return MMFILE_FORMAT_SUCCESS;
+ return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_tag_mp3 (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_mp3(MMFileFormatContext *formatContext)
{
- AvFileContentInfo *privateData = NULL;
+ AvFileContentInfo *privateData = NULL;
#ifdef __MMFILE_TEST_MODE__
debug_fenter();
#endif
- if (!formatContext || !formatContext->privateFormatData)
- {
- debug_error("formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ if (!formatContext || !formatContext->privateFormatData) {
+ debug_error("formatContext is NULL\n");
+ return MMFILE_FORMAT_FAIL;
+ }
- privateData = formatContext->privateFormatData;
+ privateData = formatContext->privateFormatData;
if (privateData->pTitle) formatContext->title = mmfile_strdup(privateData->pTitle);
if (privateData->pArtist) formatContext->artist = mmfile_strdup(privateData->pArtist);
if (privateData->pComposer) formatContext->composer = mmfile_strdup(privateData->pComposer);
if (privateData->pContentGroup) formatContext->classification = mmfile_strdup(privateData->pContentGroup);
if (privateData->pConductor) formatContext->conductor = mmfile_strdup(privateData->pConductor);
- if (privateData->pUnsyncLyrics) formatContext->unsyncLyrics= mmfile_strdup(privateData->pUnsyncLyrics);
- if (privateData->pSyncLyrics) formatContext->syncLyrics= privateData->pSyncLyrics;
- if (privateData->syncLyricsNum) formatContext->syncLyricsNum= privateData->syncLyricsNum;
- if (privateData->pRecDate) formatContext->recDate= mmfile_strdup(privateData->pRecDate);
-
- if(privateData->imageInfo.imageLen > 0)
- {
- formatContext->artwork = mmfile_malloc (privateData->imageInfo.imageLen);
- if(formatContext->artwork)
- {
+ if (privateData->pUnsyncLyrics) formatContext->unsyncLyrics = mmfile_strdup(privateData->pUnsyncLyrics);
+ if (privateData->pSyncLyrics) formatContext->syncLyrics = privateData->pSyncLyrics;
+ if (privateData->syncLyricsNum) formatContext->syncLyricsNum = privateData->syncLyricsNum;
+ if (privateData->pRecDate) formatContext->recDate = mmfile_strdup(privateData->pRecDate);
+
+ if (privateData->imageInfo.imageLen > 0) {
+ formatContext->artwork = mmfile_malloc(privateData->imageInfo.imageLen);
+ if (formatContext->artwork) {
formatContext->artworkSize = privateData->imageInfo.imageLen;
- memcpy (formatContext->artwork, privateData->imageInfo.pImageBuf, privateData->imageInfo.imageLen);
+ memcpy(formatContext->artwork, privateData->imageInfo.pImageBuf, privateData->imageInfo.imageLen);
if (strlen(privateData->imageInfo.imageMIMEType) > 0)
- formatContext->artworkMime= mmfile_strdup(privateData->imageInfo.imageMIMEType);
- else if(strlen(privateData->imageInfo.imageExt) > 0) {
- #ifdef __MMFILE_TEST_MODE__
+ formatContext->artworkMime = mmfile_strdup(privateData->imageInfo.imageMIMEType);
+ else if (strlen(privateData->imageInfo.imageExt) > 0) {
+#ifdef __MMFILE_TEST_MODE__
debug_msg("ID3 tag V2 File");
- #endif
- formatContext->artworkMime= mmfile_strdup(privateData->imageInfo.imageExt);
- }
- else {
+#endif
+ formatContext->artworkMime = mmfile_strdup(privateData->imageInfo.imageExt);
+ } else {
debug_error("Album art image exist but there is no type information of album art\n");
}
}
}
EXPORT_API
-int mmfile_format_close_mp3 (MMFileFormatContext *formatContext)
+int mmfile_format_close_mp3(MMFileFormatContext *formatContext)
{
- AvFileContentInfo *privateData = NULL;
-
- if (formatContext)
- {
- privateData = formatContext->privateFormatData;
- if (privateData)
- {
- mm_file_free_AvFileContentInfo (privateData);
- mmfile_free (privateData);
- formatContext->privateFormatData = NULL;
- }
- }
-
- return MMFILE_FORMAT_SUCCESS;
+ AvFileContentInfo *privateData = NULL;
+
+ if (formatContext) {
+ privateData = formatContext->privateFormatData;
+ if (privateData) {
+ mm_file_free_AvFileContentInfo(privateData);
+ mmfile_free(privateData);
+ formatContext->privateFormatData = NULL;
+ }
+ }
+
+ return MMFILE_FORMAT_SUCCESS;
}
static int
}
static int
-__AvGetXingHeader( AvXHeadData* headData, unsigned char *buf )
+__AvGetXingHeader(AvXHeadData *headData, unsigned char *buf)
{
int index, headFlags;
int hId, hMode, hSrIndex;
- static int mp3SamRateTable[4] = { 44100, 48000, 32000, 99999 };
+ int mp3SampleRateTable[4] = { 44100, 48000, 32000, 99999 };
- // get Xing header data
+ /* get Xing header data */
headData->flags = 0;
- // get selected MP3 header data
+ /* get selected MP3 header data */
hId = (buf[1] >> 3) & 1;
hSrIndex = (buf[2] >> 2) & 3;
hMode = (buf[3] >> 6) & 3;
- // determine offset of header
- if( hId ) // mpeg1
- {
- if( hMode != 3 )
- buf += (32+4);
+ /* determine offset of header */
+ if (hId) { /* mpeg1 */
+ if (hMode != 3)
+ buf += (32 + 4);
else
- buf += (17+4);
- }
- else // mpeg2
- {
- if( hMode != 3 )
- buf += (17+4);
+ buf += (17 + 4);
+ } else { /* mpeg2 */
+ if (hMode != 3)
+ buf += (17 + 4);
else
- buf += (9+4);
+ buf += (9 + 4);
}
/* There could be 2 attrs in this header : Xing or Info */
if (buf[0] == 'X') {
- if( buf[1] != 'i' ) return 0;
- if( buf[2] != 'n' ) return 0;
- if( buf[3] != 'g' ) return 0;
+ if (buf[1] != 'i') return 0;
+ if (buf[2] != 'n') return 0;
+ if (buf[3] != 'g') return 0;
} else if (buf[0] == 'I') {
- if( buf[1] != 'n' ) return 0;
- if( buf[2] != 'f' ) return 0;
- if( buf[3] != 'o' ) return 0;
+ if (buf[1] != 'n') return 0;
+ if (buf[2] != 'f') return 0;
+ if (buf[3] != 'o') return 0;
} else {
return 0;
}
buf += 4;
headData->hId = hId;
- headData->sampRate = mp3SamRateTable[hSrIndex];
- if( hId == 0 )
+ headData->sampRate = mp3SampleRateTable[hSrIndex];
+ if (hId == 0)
headData->sampRate >>= 1;
- headFlags = headData->flags = __AvExtractI4( buf ); // get flags
- buf+=4;
+ headFlags = headData->flags = __AvExtractI4(buf); /* get flags */
+ buf += 4;
- if( headFlags & FRAMES_FLAG )
- {
- headData->frames = __AvExtractI4( buf );
- buf+=4;
+ if (headFlags & FRAMES_FLAG) {
+ headData->frames = __AvExtractI4(buf);
+ buf += 4;
}
- if( headFlags & BYTES_FLAG )
- {
- headData->bytes = __AvExtractI4( buf );
- buf+=4;
+ if (headFlags & BYTES_FLAG) {
+ headData->bytes = __AvExtractI4(buf);
+ buf += 4;
}
- if( headFlags & TOC_FLAG )
- {
- if( headData->toc != NULL )
- {
- for( index = 0; index < 100; index++ )
+ if (headFlags & TOC_FLAG) {
+ if (headData->toc != NULL) {
+ for (index = 0; index < 100; index++)
headData->toc[index] = buf[index];
}
- buf+=100;
+ buf += 100;
}
headData->vbrScale = -1;
- if( headFlags & VBR_SCALE_FLAG )
- {
- headData->vbrScale = __AvExtractI4( buf );
- buf+=4;
+ if (headFlags & VBR_SCALE_FLAG) {
+ headData->vbrScale = __AvExtractI4(buf);
+ buf += 4;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Xing header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
- headData->sampRate, headData->bytes, headData->frames);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Xing header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
+ headData->sampRate, headData->bytes, headData->frames);
+#endif
- return 1; // success
+ return 1; /* success */
}
static int
-__AvGetVBRIHeader( AvVBRIHeadData* headData, unsigned char *buf )
+__AvGetVBRIHeader(AvVBRIHeadData *headData, unsigned char *buf)
{
int hId, hSrIndex;
- static int mp3SamRateTable[4] = { 44100, 48000, 32000, 99999 };
+ int mp3SampleRateTable[4] = { 44100, 48000, 32000, 99999 };
- // get selected MP3 header data
+ /* get selected MP3 header data */
hId = (buf[1] >> 3) & 1;
hSrIndex = (buf[2] >> 2) & 3;
- buf += (32+4);
+ buf += (32 + 4);
- if( buf[0] != 'V' ) return 0; // fail
- if( buf[1] != 'B' ) return 0; // header not found
- if( buf[2] != 'R' ) return 0;
- if( buf[3] != 'I' ) return 0;
+ if (buf[0] != 'V') return 0; /* fail */
+ if (buf[1] != 'B') return 0; /* header not found */
+ if (buf[2] != 'R') return 0;
+ if (buf[3] != 'I') return 0;
buf += 4;
headData->hId = hId;
- headData->sampRate = mp3SamRateTable[hSrIndex];
- if( hId == 0 )
+ headData->sampRate = mp3SampleRateTable[hSrIndex];
+ if (hId == 0)
headData->sampRate >>= 1;
- headData->vID = __AvExtractI2( buf ); // get ver ID
- buf+=2;
- headData->delay = __AvExtractI2( buf );
- buf+=2;
+ headData->vID = __AvExtractI2(buf); /* get ver ID */
+ buf += 2;
+ headData->delay = __AvExtractI2(buf);
+ buf += 2;
headData->qualityIndicator = buf[0];
- buf+=2;
- headData->bytes = __AvExtractI4( buf );
- buf+=4;
- headData->frames= __AvExtractI4( buf );
- buf+=4;
- headData->numOfTOC = __AvExtractI2( buf );
- buf+=2;
- headData->vbriScale = __AvExtractI2( buf );
- buf+=2;
- headData->sizePerTable = __AvExtractI2( buf );
- buf+=2;
- headData->framesPerTable = __AvExtractI2( buf );
- buf+=2;
-
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Vbri header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
- headData->sampRate, headData->bytes, headData->frames);
- #endif
-
- return true; // success
+ buf += 2;
+ headData->bytes = __AvExtractI4(buf);
+ buf += 4;
+ headData->frames = __AvExtractI4(buf);
+ buf += 4;
+ headData->numOfTOC = __AvExtractI2(buf);
+ buf += 2;
+ headData->vbriScale = __AvExtractI2(buf);
+ buf += 2;
+ headData->sizePerTable = __AvExtractI2(buf);
+ buf += 2;
+ headData->framesPerTable = __AvExtractI2(buf);
+ buf += 2;
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Vbri header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
+ headData->sampRate, headData->bytes, headData->frames);
+#endif
+
+ return true; /* success */
}
static bool
-__AvIsValidHeader(AvFileContentInfo* pInfo, unsigned char *buf)
+__AvIsValidHeader(AvFileContentInfo *pInfo, unsigned char *buf)
{
bool bSync = false;
- if (VALID_SYNC(buf))
- {
+ if (VALID_SYNC(buf)) {
mp3FrameDataValid[0] = (0xFF) & (mp3FrameMasking[0]);
mp3FrameDataValid[1] = (0xE0 | (buf[AV_MP3HDR_VERSION_OFS] & AV_MP3HDR_VERSION_M)
- | (buf[AV_MP3HDR_LAYER_OFS] & AV_MP3HDR_LAYER_M)) & (mp3FrameMasking[1]);
+ | (buf[AV_MP3HDR_LAYER_OFS] & AV_MP3HDR_LAYER_M)) & (mp3FrameMasking[1]);
mp3FrameDataValid[2] = (buf[AV_MP3HDR_SAMPLERATE_OFS] & AV_MP3HDR_SAMPLERATE_M) &
- (mp3FrameMasking[2]);
+ (mp3FrameMasking[2]);
mp3FrameDataValid[3] = (buf[AV_MP3HDR_CHANNEL_OFS] & AV_MP3HDR_CHANNEL_M) &
- (mp3FrameMasking[3]);
+ (mp3FrameMasking[3]);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("*** [%02x][%02x][%02x][%02x] : [%02x][%02x][%02x][%02x]",
- buf[0], buf[1], buf[2],buf[3],
- mp3FrameDataValid[0], mp3FrameDataValid[1], mp3FrameDataValid[2],mp3FrameDataValid[3]);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("*** [%02x][%02x][%02x][%02x] : [%02x][%02x][%02x][%02x]",
+ buf[0], buf[1], buf[2], buf[3],
+ mp3FrameDataValid[0], mp3FrameDataValid[1], mp3FrameDataValid[2], mp3FrameDataValid[3]);
+#endif
/*
* MPEG Audio Layer I/II/III frame header
*/
/* Simple check for version, layer, bitrate, samplerate */
- if ( (buf[1] & 0x18) != 0x08 && /* 000XX000 : MPEG Audio version ID, XX=01 - reserved => 00001000(0x08) */
- (buf[1] & 0x06) != 0x00 && /* 00000XX0 : Layer description, XX=00 - reserved => 00000000(0x00) */
- (buf[2] & 0xF0) != 0xF0 && /* XXXX0000 : Bitrate index, XX=1111 - bad => 11110000(0xF0) */
- (buf[2] & 0x0C) != 0x0C) /* 0000XX00 : Sampling rate frequency index , XX=11 -reserved => 00001100(0x0C) */
- {
+ if ((buf[1] & 0x18) != 0x08 && /* 000XX000 : MPEG Audio version ID, XX=01 - reserved => 00001000(0x08) */
+ (buf[1] & 0x06) != 0x00 && /* 00000XX0 : Layer description, XX=00 - reserved => 00000000(0x00) */
+ (buf[2] & 0xF0) != 0xF0 && /* XXXX0000 : Bitrate index, XX=1111 - bad => 11110000(0xF0) */
+ (buf[2] & 0x0C) != 0x0C) { /* 0000XX00 : Sampling rate frequency index, XX=11 -reserved => 00001100(0x0C) */
bSync = true;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("=> %s\n", bSync? "Good!":"Bad...");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("=> %s\n", bSync ? "Good!" : "Bad...");
+#endif
}
- if(bSync == true)
+ if (bSync == true)
return true;
- else
+ else
return false;
}
static bool
-__AvParseMp3Header( AvFileContentInfo* pInfo, unsigned char* header )
+__AvParseMp3Header(AvFileContentInfo *pInfo, unsigned char *header)
{
unsigned char result;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("### [%02x][%02x][%02x][%02x] ###\n", header[0], header[1], header[2],header[3]);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("### [%02x][%02x][%02x][%02x] ###\n", header[0], header[1], header[2], header[3]);
+#endif
- // 1. Check the version of mp3
+ /* 1. Check the version of mp3 */
result = header[1] & MASK_MPEG;
- switch (result)
- {
- case MASK_MPEG_1:
- pInfo->mpegVersion = AV_MPEG_VER_1;
- break;
- case MASK_MPEG_2:
- pInfo->mpegVersion = AV_MPEG_VER_2;
- break;
- case MASK_MPEG_25:
- pInfo->mpegVersion = AV_MPEG_VER_25;
- break;
- default:
- return false;
+ switch (result) {
+ case MASK_MPEG_1:
+ pInfo->mpegVersion = AV_MPEG_VER_1;
+ break;
+ case MASK_MPEG_2:
+ pInfo->mpegVersion = AV_MPEG_VER_2;
+ break;
+ case MASK_MPEG_25:
+ pInfo->mpegVersion = AV_MPEG_VER_25;
+ break;
+ default:
+ return false;
}
- // 2. Get a layer
+ /* 2. Get a layer */
result = header[1] & MASK_LAYER;
- switch (result)
- {
- case MASK_LAYER_1:
- pInfo->layer = AV_MP3_LAYER_1;
- break;
- case MASK_LAYER_2:
- pInfo->layer = AV_MP3_LAYER_2;
- break;
- case MASK_LAYER_3:
- pInfo->layer = AV_MP3_LAYER_3;
- break;
- default:
- return false;
+ switch (result) {
+ case MASK_LAYER_1:
+ pInfo->layer = AV_MP3_LAYER_1;
+ break;
+ case MASK_LAYER_2:
+ pInfo->layer = AV_MP3_LAYER_2;
+ break;
+ case MASK_LAYER_3:
+ pInfo->layer = AV_MP3_LAYER_3;
+ break;
+ default:
+ return false;
}
-
- // 3. bitrate
+
+ /* 3. bitrate */
result = header[2] >> 4;
- if ( pInfo->mpegVersion == AV_MPEG_VER_1 )
- pInfo->bitRate = mp3BitRateTable[0][pInfo->layer-1][(int)result] ;
+ if (pInfo->mpegVersion == AV_MPEG_VER_1)
+ pInfo->bitRate = mp3BitRateTable[0][pInfo->layer - 1][(int)result] ;
else
- pInfo->bitRate = mp3BitRateTable[1][pInfo->layer-1][(int)result] ;
+ pInfo->bitRate = mp3BitRateTable[1][pInfo->layer - 1][(int)result] ;
- // 4. samplerate
- result = ( header[2] & MASK_SAMPLERATE ) >> 2;
- if ( result == 0x03 )
+ /* 4. samplerate */
+ result = (header[2] & MASK_SAMPLERATE) >> 2;
+ if (result == 0x03)
return false;
else
pInfo->sampleRate = mp3SamRateTable[pInfo->mpegVersion - 1][(int)result];
-
- // 5. channel
+
+ /* 5. channel */
result = header[3] & MASK_CHANNEL;
- switch (result)
- {
- case MASK_CHANNEL_ST:
- pInfo->channelIndex = 0;
- pInfo->channels = 2;
- break;
- case MASK_CHANNEL_JS:
- pInfo->channelIndex = 1;
- pInfo->channels = 2;
- break;
- case MASK_CHANNEL_DC:
- pInfo->channelIndex = 2;
- pInfo->channels = 2;
- break;
- case MASK_CHANNEL_MN:
- pInfo->channelIndex = 3;;
- pInfo->channels = 1;
- break;
- default:
- return false;
+ switch (result) {
+ case MASK_CHANNEL_ST:
+ pInfo->channelIndex = 0;
+ pInfo->channels = 2;
+ break;
+ case MASK_CHANNEL_JS:
+ pInfo->channelIndex = 1;
+ pInfo->channels = 2;
+ break;
+ case MASK_CHANNEL_DC:
+ pInfo->channelIndex = 2;
+ pInfo->channels = 2;
+ break;
+ case MASK_CHANNEL_MN:
+ pInfo->channelIndex = 3;;
+ pInfo->channels = 1;
+ break;
+ default:
+ return false;
}
- // 6. padding
+ /* 6. padding */
result = header[2] & MASK_PADDING;
- if ( result == MASK_PADDING )
+ if (result == MASK_PADDING)
pInfo->bPadding = true;
else
pInfo->bPadding = false;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("=> samplerate=%d, bitrate=%d, layer=%d, version=%d, channel=%d, padding=%d",
- pInfo->sampleRate, pInfo->bitRate, pInfo->layer, pInfo->mpegVersion, pInfo->channels, pInfo->bPadding );
- #endif
-
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("=> samplerate=%d, bitrate=%d, layer=%d, version=%d, channel=%d, padding=%d",
+ pInfo->sampleRate, pInfo->bitRate, pInfo->layer, pInfo->mpegVersion, pInfo->channels, pInfo->bPadding);
+#endif
+
return true;
}
static bool
-__AvParseXingHeader( AvFileContentInfo* pInfo, unsigned char* buf )
+__AvParseXingHeader(AvFileContentInfo *pInfo, unsigned char *buf)
{
AvXHeadData data;
- memset( &data, 0x00, sizeof(AvXHeadData) );
+ memset(&data, 0x00, sizeof(AvXHeadData));
- // 1. Xing Header
+ /* 1. Xing Header */
/* There could be 2 attrs in this header : Xing or Info */
- if((pInfo->mpegVersion == AV_MPEG_VER_1) && (pInfo->channels == 2))
- {
- if (buf[36] =='X') {
- if( buf[37] != 'i' ) return false;
- if( buf[38] != 'n' ) return false;
- if( buf[39] != 'g' ) return false;
+ if ((pInfo->mpegVersion == AV_MPEG_VER_1) && (pInfo->channels == 2)) {
+ if (buf[36] == 'X') {
+ if (buf[37] != 'i') return false;
+ if (buf[38] != 'n') return false;
+ if (buf[39] != 'g') return false;
} else if (buf[36] == 'I') {
- if( buf[37] != 'n' ) return false;
- if( buf[38] != 'f' ) return false;
- if( buf[39] != 'o' ) return false;
+ if (buf[37] != 'n') return false;
+ if (buf[38] != 'f') return false;
+ if (buf[39] != 'o') return false;
} else {
return false;
}
- }
- else
- if((pInfo->mpegVersion == AV_MPEG_VER_2 || pInfo->mpegVersion == AV_MPEG_VER_25) && (pInfo->channels == 1))
- {
- if (buf[13] =='X') {
- if( buf[14] != 'i' ) return false;
- if( buf[15] != 'n' ) return false;
- if( buf[16] != 'g' ) return false;
+ } else if ((pInfo->mpegVersion == AV_MPEG_VER_2 || pInfo->mpegVersion == AV_MPEG_VER_25) && (pInfo->channels == 1)) {
+ if (buf[13] == 'X') {
+ if (buf[14] != 'i') return false;
+ if (buf[15] != 'n') return false;
+ if (buf[16] != 'g') return false;
} else if (buf[13] == 'I') {
- if( buf[14] != 'n' ) return false;
- if( buf[15] != 'f' ) return false;
- if( buf[16] != 'o' ) return false;
+ if (buf[14] != 'n') return false;
+ if (buf[15] != 'f') return false;
+ if (buf[16] != 'o') return false;
} else {
return false;
}
- }
- else
- {
- if (buf[21] =='X') {
- if( buf[22] != 'i' ) return false;
- if( buf[23] != 'n' ) return false;
- if( buf[24] != 'g' ) return false;
+ } else {
+ if (buf[21] == 'X') {
+ if (buf[22] != 'i') return false;
+ if (buf[23] != 'n') return false;
+ if (buf[24] != 'g') return false;
} else if (buf[21] == 'I') {
- if( buf[22] != 'n' ) return false;
- if( buf[23] != 'f' ) return false;
- if( buf[24] != 'o' ) return false;
+ if (buf[22] != 'n') return false;
+ if (buf[23] != 'f') return false;
+ if (buf[24] != 'o') return false;
} else {
return false;
}
}
- // 2. TOC
- if ( pInfo->pToc )
+ /* 2. TOC */
+ if (pInfo->pToc)
data.toc = (unsigned char *)(pInfo->pToc);
- if ( __AvGetXingHeader( &data, (unsigned char *)buf ) == 1 ) // VBR.
- {
+ if (__AvGetXingHeader(&data, (unsigned char *)buf) == 1) { /* VBR. */
if (data.sampRate == 0 || data.bytes == 0 || data.frames == 0) {
- debug_error ("invalid Xing header\n");
+ debug_error("invalid Xing header\n");
return false;
}
pInfo->datafileLen = data.bytes;
pInfo->frameNum = data.frames;
- pInfo->frameSize = (int) ( (float) data.bytes / (float) data.frames ) ;
+ pInfo->frameSize = (int)((float) data.bytes / (float) data.frames) ;
pInfo->bVbr = true;
return true;
- }
- else
+ } else
return false;
}
static bool
-__AvParseVBRIHeader( AvFileContentInfo* pInfo, unsigned char* buf )
+__AvParseVBRIHeader(AvFileContentInfo *pInfo, unsigned char *buf)
{
AvVBRIHeadData data;
- memset( &data, 0x00, sizeof(AvVBRIHeadData) );
-
- // 1. Xing Header
- if((pInfo->mpegVersion == AV_MPEG_VER_1) && (pInfo->channels == 2))
- {
- if( buf[36] != 'V' ) return false;
- if( buf[37] != 'B' ) return false;
- if( buf[38] != 'R' ) return false;
- if( buf[39] != 'I' ) return false;
- }
- else
- if((pInfo->mpegVersion == AV_MPEG_VER_2) && (pInfo->channels == 1))
- {
- if( buf[36] != 'V' ) return false;
- if( buf[37] != 'B' ) return false;
- if( buf[38] != 'R' ) return false;
- if( buf[39] != 'I' ) return false;
- }
- else
- {
- if( buf[36] != 'V' ) return false;
- if( buf[37] != 'B' ) return false;
- if( buf[38] != 'R' ) return false;
- if( buf[39] != 'I' ) return false;
+ memset(&data, 0x00, sizeof(AvVBRIHeadData));
+
+ /* 1. Xing Header */
+ if ((pInfo->mpegVersion == AV_MPEG_VER_1) && (pInfo->channels == 2)) {
+ if (buf[36] != 'V') return false;
+ if (buf[37] != 'B') return false;
+ if (buf[38] != 'R') return false;
+ if (buf[39] != 'I') return false;
+ } else if ((pInfo->mpegVersion == AV_MPEG_VER_2) && (pInfo->channels == 1)) {
+ if (buf[36] != 'V') return false;
+ if (buf[37] != 'B') return false;
+ if (buf[38] != 'R') return false;
+ if (buf[39] != 'I') return false;
+ } else {
+ if (buf[36] != 'V') return false;
+ if (buf[37] != 'B') return false;
+ if (buf[38] != 'R') return false;
+ if (buf[39] != 'I') return false;
}
- // 2. TOC
- if ( pInfo->pToc )
- data.toc = (unsigned char*)(pInfo->pToc);
+ /* 2. TOC */
+ if (pInfo->pToc)
+ data.toc = (unsigned char *)(pInfo->pToc);
- if ( __AvGetVBRIHeader( &data, (unsigned char*)buf ) == 1 ) // VBR.
- {
+ if (__AvGetVBRIHeader(&data, (unsigned char *)buf) == 1) { /* VBR. */
if (data.sampRate == 0 || data.bytes == 0 || data.frames == 0) {
- debug_error ("invalid Vbri header\n");
+ debug_error("invalid Vbri header\n");
return false;
}
pInfo->sampleRate = data.sampRate;
pInfo->datafileLen = data.bytes;
pInfo->frameNum = data.frames;
- pInfo->frameSize = (int) ( (float) data.bytes / (float) data.frames ) ;
+ pInfo->frameSize = (int)((float) data.bytes / (float) data.frames) ;
pInfo->bVbr = true;
return true;
- }
- else
+ } else
return false;
}
-#ifdef __MMFILE_NEW_FRAME_FUNC // from gst
+#ifdef __MMFILE_NEW_FRAME_FUNC /* from gst */
static bool
-__AvGetMp3FrameSize( AvFileContentInfo* pInfo )
+__AvGetMp3FrameSize(AvFileContentInfo *pInfo)
{
unsigned int frameSize = 0;
- if ( pInfo == NULL )
+ if (pInfo == NULL)
return false;
frameSize = pInfo->bPadding;
- if (pInfo->bitRate == 0) {
- if (pInfo->layer == 1) {
- frameSize *= 4;
- frameSize += 0/* FIXME: possible_free_framelen*/;
- pInfo->bitRate = frameSize * pInfo->sampleRate / 48000;
- } else {
- frameSize += 0/* FIXME: possible_free_framelen*/;
- pInfo->bitRate = frameSize * pInfo->sampleRate /
- ((pInfo->layer == AV_MP3_LAYER_3 && pInfo->mpegVersion != AV_MPEG_VER_1) ? 72000 : 144000);
- }
- } else {
- /* calculating */
- if (pInfo->layer == 1) {
- frameSize = ((12000 * pInfo->bitRate / pInfo->sampleRate) + frameSize) * 4;
- } else {
- frameSize += ((pInfo->layer == AV_MP3_LAYER_3
- && pInfo->mpegVersion != AV_MPEG_VER_1) ? 72000 : 144000) * pInfo->bitRate / pInfo->sampleRate;
- }
- }
+ if (pInfo->bitRate == 0) {
+ if (pInfo->layer == 1) {
+ frameSize *= 4;
+ frameSize += 0/* FIXME: possible_free_framelen*/;
+ pInfo->bitRate = frameSize * pInfo->sampleRate / 48000;
+ } else {
+ frameSize += 0/* FIXME: possible_free_framelen*/;
+ pInfo->bitRate = frameSize * pInfo->sampleRate /
+ ((pInfo->layer == AV_MP3_LAYER_3 && pInfo->mpegVersion != AV_MPEG_VER_1) ? 72000 : 144000);
+ }
+ } else {
+ /* calculating */
+ if (pInfo->layer == 1) {
+ frameSize = ((12000 * pInfo->bitRate / pInfo->sampleRate) + frameSize) * 4;
+ } else {
+ frameSize += ((pInfo->layer == AV_MP3_LAYER_3
+ && pInfo->mpegVersion != AV_MPEG_VER_1) ? 72000 : 144000) * pInfo->bitRate / pInfo->sampleRate;
+ }
+ }
pInfo->frameSize = (int)frameSize;
#endif
-static bool
-__AvGetXingBitrate( AvFileContentInfo* pInfo )
+static bool
+__AvGetXingBitrate(AvFileContentInfo *pInfo)
{
float br, factor;
int padding;
- if ( pInfo == NULL || pInfo->bVbr == false )
+ if (pInfo == NULL || pInfo->bVbr == false)
return false;
- if ( pInfo->bPadding )
+ if (pInfo->bPadding)
padding = 1;
else
padding = 0;
- if (pInfo->mpegVersion == AV_MPEG_VER_1 ) // MPEG version 1
- {
- if (pInfo->layer == AV_MP3_LAYER_1 ) // Layer 1
+ if (pInfo->mpegVersion == AV_MPEG_VER_1) { /* MPEG version 1 */
+ if (pInfo->layer == AV_MP3_LAYER_1) /* Layer 1 */
factor = 48000.0;
- else // Layer 2, 3
+ else /* Layer 2, 3 */
factor = 144000.0;
- }
- else // MPEG version 2
- {
- if (pInfo->layer == AV_MP3_LAYER_1 ) // Layer 1
+ } else { /* MPEG version 2 */
+ if (pInfo->layer == AV_MP3_LAYER_1) /* Layer 1 */
factor = 24000.0;
- else // Layer 2, 3
+ else /* Layer 2, 3 */
factor = 72000.0;
}
- br = ( pInfo->frameSize - padding ) * pInfo->sampleRate / factor;
+ br = (pInfo->frameSize - padding) * pInfo->sampleRate / factor;
pInfo->bitRate = (int) br;
}
static bool
-__AvGetVBRIBitrate( AvFileContentInfo* pInfo )
+__AvGetVBRIBitrate(AvFileContentInfo *pInfo)
{
float br, factor;
int padding;
- if ( pInfo == NULL || pInfo->bVbr == false )
+ if (pInfo == NULL || pInfo->bVbr == false)
return false;
- if ( pInfo->bPadding )
+ if (pInfo->bPadding)
padding = 1;
else
padding = 0;
- if (pInfo->mpegVersion == AV_MPEG_VER_1 ) // MPEG version 1
- {
- if (pInfo->layer == AV_MP3_LAYER_1 ) // Layer 1
+ if (pInfo->mpegVersion == AV_MPEG_VER_1) { /* MPEG version 1 */
+ if (pInfo->layer == AV_MP3_LAYER_1) /* Layer 1 */
factor = 48000.0;
- else // Layer 2, 3
+ else /* Layer 2, 3 */
factor = 144000.0;
- }
- else // MPEG version 2
- {
- if (pInfo->layer == AV_MP3_LAYER_1 ) // Layer 1
+ } else { /* MPEG version 2 */
+ if (pInfo->layer == AV_MP3_LAYER_1) /* Layer 1 */
factor = 24000.0;
- else // Layer 2, 3
+ else /* Layer 2, 3 */
factor = 72000.0;
}
- br = ( pInfo->frameSize - padding ) * pInfo->sampleRate / factor;
+ br = (pInfo->frameSize - padding) * pInfo->sampleRate / factor;
pInfo->bitRate = (int) br;
return true;
}
-static int __AvGetLastID3offset (MMFileIOHandle *fp, unsigned int *offset)
+static int __AvGetLastID3offset(MMFileIOHandle *fp, unsigned int *offset)
{
#define _MMFILE_MP3_TAGV2_HEADER_LEN 10
-#define _MMFILE_GET_INT_NUMBER(buff) (int)( (((int)(buff)[0]) << 24) | (((int)(buff)[1]) << 16) | (((int)(buff)[2]) << 8) | (((int)(buff)[3])))
+#define _MMFILE_GET_INT_NUMBER(buff) (int)((((int)(buff)[0]) << 24) | (((int)(buff)[1]) << 16) | (((int)(buff)[2]) << 8) | (((int)(buff)[3])))
- unsigned char tagHeader[_MMFILE_MP3_TAGV2_HEADER_LEN] = {0,};
+ unsigned char tagHeader[_MMFILE_MP3_TAGV2_HEADER_LEN] = {0, };
unsigned int tagInfoSize = 0;
unsigned int acc_tagsize = 0;
int tagVersion = 0;
*offset = 0;
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
-
+
_START_TAG_SEARCH:
- readed = mmfile_read (fp, tagHeader, _MMFILE_MP3_TAGV2_HEADER_LEN);
+ readed = mmfile_read(fp, tagHeader, _MMFILE_MP3_TAGV2_HEADER_LEN);
if (readed != _MMFILE_MP3_TAGV2_HEADER_LEN) {
- debug_error ("read error occured.\n");
+ debug_error("read error occured.\n");
return 0;
}
- if (memcmp (tagHeader, "ID3", 3) == 0) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("'ID3' found.\n");
- #endif
+ if (memcmp(tagHeader, "ID3", 3) == 0) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("'ID3' found.\n");
+#endif
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("'ID3' not found.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("'ID3' not found.\n");
+#endif
goto search_end;
}
/**@note weak id3v2 tag checking*/
if (tagHeader[3] != 0xFF && tagHeader[4] != 0xFF &&
- (tagHeader[6] & 0x80) == 0 && (tagHeader[7] & 0x80) == 0 &&
- (tagHeader[8] & 0x80) == 0 && (tagHeader[9] & 0x80) == 0) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("good ID3V2 tag.\n");
- #endif
+ (tagHeader[6] & 0x80) == 0 && (tagHeader[7] & 0x80) == 0 &&
+ (tagHeader[8] & 0x80) == 0 && (tagHeader[9] & 0x80) == 0) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("good ID3V2 tag.\n");
+#endif
} else {
- debug_warning ("It's bad ID3V2 tag.\n");
+ debug_warning("It's bad ID3V2 tag.\n");
goto search_end;
}
tagVersion = tagHeader[3];
if (tagVersion > 4) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("Tag version not supported\n");
- #endif
+#endif
goto search_end;
}
/**@note unfortunately, some contents has many id3 tag.*/
acc_tagsize += tagInfoSize;
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
- #endif
+#endif
mmfile_seek(fp, acc_tagsize, MMFILE_SEEK_SET);
*offset = acc_tagsize;
* This function returns the start position of header.
*/
static int
-__AvFindStartOfMp3Header(MMFileIOHandle *hFile, unsigned char *buf, AvFileContentInfo* pInfo)
+__AvFindStartOfMp3Header(MMFileIOHandle *hFile, unsigned char *buf, AvFileContentInfo *pInfo)
{
- int index=0;
+ unsigned int index = 0;
long readLen;
unsigned long id3v2TagLen = 0;
unsigned char *pHeader = NULL;
bool bFoundSync = false;
unsigned long minLen;
-
- if(pInfo->fileLen > (_AV_MP3_HEADER_POSITION_MAX+ pInfo->tagV2Info.tagLen))
+
+ if (pInfo->fileLen > (_AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen))
bufLen = _AV_MP3_HEADER_POSITION_MAX;
else
- bufLen = pInfo ->fileLen - pInfo->tagV2Info.tagLen;
+ bufLen = pInfo->fileLen - pInfo->tagV2Info.tagLen;
- if(IS_ID3V2_TAG(buf))
- {
-
+ if (IS_ID3V2_TAG(buf)) {
- if(pInfo->tagV2Info.tagVersion == 0x02)
- {
-
- if(!mm_file_id3tag_parse_v222(pInfo, buf))
+
+ if (pInfo->tagV2Info.tagVersion == 0x02) {
+
+ if (!mm_file_id3tag_parse_v222(pInfo, buf))
pInfo->tagV2Info.tagLen = 0;
- }
- else if (pInfo->tagV2Info.tagVersion == 0x03)
- {
-
- if(!mm_file_id3tag_parse_v223(pInfo, buf))
+ } else if (pInfo->tagV2Info.tagVersion == 0x03) {
+
+ if (!mm_file_id3tag_parse_v223(pInfo, buf))
pInfo->tagV2Info.tagLen = 0;
- }
- else if (pInfo->tagV2Info.tagVersion == 0x04)
- {
-
- if(!mm_file_id3tag_parse_v224(pInfo, buf)) // currently 2.4 ver pased by 2.3 routine
+ } else if (pInfo->tagV2Info.tagVersion == 0x04) {
+
+ if (!mm_file_id3tag_parse_v224(pInfo, buf)) /* currently 2.4 ver pased by 2.3 routine */
pInfo->tagV2Info.tagLen = 0;
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagVersion);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagVersion);
+#endif
}
id3v2TagLen = pInfo->tagV2Info.tagLen;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "id3v2TagLen(%d)\n", id3v2TagLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("id3v2TagLen(%d)\n", id3v2TagLen);
+#endif
- if(id3v2TagLen)
- {
- if (mmfile_seek (hFile, id3v2TagLen, SEEK_SET) < 0) {
- debug_error ( "seek failed.\n");
+ if (id3v2TagLen) {
+ if (mmfile_seek(hFile, id3v2TagLen, SEEK_SET) < 0) {
+ debug_error("seek failed.\n");
return -1;
}
- if ((readLen = mmfile_read (hFile, buf, bufLen)) <= 0) {
- debug_error ( "seek failed.\n");
+ if ((readLen = mmfile_read(hFile, buf, bufLen)) <= 0) {
+ debug_error("seek failed.\n");
return -1;
}
}
- while(1)
- {
- if (preHeaderGap == bufLen -2)
+ while (1) {
+ if (preHeaderGap == bufLen - 2)
break;
- if(__AvIsValidHeader(pInfo, buf+preHeaderGap))
+ if (__AvIsValidHeader(pInfo, buf + preHeaderGap))
break;
preHeaderGap++;
}
-
- }
- else
- {
- while(1)
- {
- if (preHeaderGap == bufLen -2)
+
+ } else {
+ while (1) {
+ if (preHeaderGap == bufLen - 2)
+ break;
+ if (__AvIsValidHeader(pInfo, buf + preHeaderGap))
break;
- if(__AvIsValidHeader(pInfo, buf+preHeaderGap))
- break;
preHeaderGap++;
}
buf += preHeaderGap;
index += preHeaderGap;
- while (index <= (bufLen - minLen))
- {
- if(buf[0] == 0xff)
- {
- if(VALID_SYNC(buf))
- {
- if(bufLen - index > 256)
- {
- pHeader = mmfile_malloc (256);
- if (pHeader == NULL)
- {
- debug_error ( "malloc failed.\n");
+ while (index <= (bufLen - minLen)) {
+ if (buf[0] == 0xff) {
+ if (VALID_SYNC(buf)) {
+ if (bufLen - index > 256) {
+ pHeader = mmfile_malloc(256);
+ if (pHeader == NULL) {
+ debug_error("malloc failed.\n");
return -1;
}
strncpy((char *)pHeader, (char *)buf, 256);
- }
- else
- {
- debug_error ( "Header field is not exist\n");
+ } else {
+ debug_error("Header field is not exist\n");
return -1;
}
- if ( __AvParseMp3Header( pInfo, pHeader ) == false)
- {
- //return -1;
- if(pHeader)
+ if (__AvParseMp3Header(pInfo, pHeader) == false) {
+ /*return -1; */
+ if (pHeader)
_FREE_EX(pHeader);
- debug_warning ( "Mp3 parse header failed & index(%d)\n", index);
+ debug_warning("Mp3 parse header failed & index(%d)\n", index);
buf++;
index++;
continue;
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "This header is valid. index(%d)\n", index);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("This header is valid. index(%d)\n", index);
+#endif
}
- if ( __AvParseXingHeader( pInfo, pHeader ) )
- {
- __AvGetXingBitrate( pInfo );
- }
- else if(__AvParseVBRIHeader( pInfo, pHeader ))
- {
- __AvGetVBRIBitrate( pInfo );
+ if (__AvParseXingHeader(pInfo, pHeader)) {
+ __AvGetXingBitrate(pInfo);
+ } else if (__AvParseVBRIHeader(pInfo, pHeader)) {
+ __AvGetVBRIBitrate(pInfo);
}
-
- if (pInfo->bVbr)
- {
- if(pHeader)
+
+ if (pInfo->bVbr) {
+ if (pHeader)
_FREE_EX(pHeader);
bFoundSync = true;
break;
- }
- else
- {
- if(__AvIsValidHeader(pInfo, pHeader))
- {
- if(pHeader)
+ } else {
+ if (__AvIsValidHeader(pInfo, pHeader)) {
+ if (pHeader)
_FREE_EX(pHeader);
-
- __AvGetMp3FrameSize( pInfo );
+
+ __AvGetMp3FrameSize(pInfo);
pInfo->datafileLen = pInfo->fileLen - pInfo->headerPos;
frameLen = pInfo->frameSize;
- if (frameLen)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("<<< frameLen=[%d] >>> \n", frameLen);
- #endif
+ if (frameLen) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("<<< frameLen=[%d] >>> \n", frameLen);
+#endif
- #ifndef __MMFILE_NEW_FRAME_FUNC // FIXME : what purpose to do this?
+#ifndef __MMFILE_NEW_FRAME_FUNC /* FIXME : what purpose to do this? */
/* Account for loss of precision in the frame length calculation*/
frameLen--;
- #endif
+#endif
/* Check if the remaining buffer size is large enough to
* look for another sync */
- if ((index + frameLen) < (bufLen - (minLen - 1)))
- {
+ if ((index + frameLen) < (bufLen - (minLen - 1))) {
nextFrameOff = frameLen;
- nextFrameOffEnd = nextFrameOff +MIN(6, bufLen - (index+frameLen) - (minLen - 1));
+ nextFrameOffEnd = nextFrameOff + MIN(6, bufLen - (index + frameLen) - (minLen - 1));
/* Search the next few bytes for the next sync */
- while (nextFrameOff < nextFrameOffEnd)
- {
- if (VALID_SYNC(buf+nextFrameOff))
- {
- if(IS_VALID_FRAME_MP3(buf+nextFrameOff))
- {
+ while (nextFrameOff < nextFrameOffEnd) {
+ if (VALID_SYNC(buf + nextFrameOff)) {
+ if (IS_VALID_FRAME_MP3(buf + nextFrameOff)) {
bFoundSync = true;
break;
}
}
nextFrameOff++;
}
- if (bFoundSync == true)
+ if (bFoundSync == true)
break;
- }
- else
- {
+ } else {
/* Assume that the first sync is valid, since there is not
* enough data in the buffer to look for the next sync */
bFoundSync = true;
- break;
+ break;
}
}
- }
- else
- {
- debug_warning ( "Is not vaild header pHeader\n");
+ } else {
+ debug_warning("Is not vaild header pHeader\n");
}
}
- if(pHeader)
+ if (pHeader)
_FREE_EX(pHeader);
- }
- else
- {
- debug_warning ( "Mp3 file frist byte is 0xff, but not header sync\n");
+ } else {
+ debug_warning("Mp3 file frist byte is 0xff, but not header sync\n");
}
}
buf++;
index++;
}
- _FREE_EX (pHeader);
+ _FREE_EX(pHeader);
if (mmfile_seek(hFile, 0, SEEK_SET) < 0) {
- debug_error ( "seek error!\n");
+ debug_error("seek error!\n");
return -1;
}
- if(index > (bufLen - minLen))
- {
- debug_warning ( "Mp3 file sync is not found : index(%d) bufLen(%d), minLen(%d)\n", index, bufLen, minLen);
+ if (index > (bufLen - minLen)) {
+ debug_warning("Mp3 file sync is not found : index(%d) bufLen(%d), minLen(%d)\n", index, bufLen, minLen);
return -1;
}
-
- if(bFoundSync == true)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Mp3 file found a sync Success!\n");
- #endif
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Mp3 file found a sync Failed!\n");
- #endif
+
+ if (bFoundSync == true) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Mp3 file found a sync Success!\n");
+#endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Mp3 file found a sync Failed!\n");
+#endif
return -1;
}
- return index+id3v2TagLen;
+ return index + id3v2TagLen;
}
/*
* Param _frame [out] Specifies a struct pointer for mp3 information.
* This function returns true on success, or false on failure.
*/
-static int mmf_file_mp3_get_infomation (char *filename, AvFileContentInfo* pInfo )
+static int mmf_file_mp3_get_infomation(char *filename, AvFileContentInfo *pInfo)
{
MMFileIOHandle *hFile;
unsigned char header[256];
- unsigned long frameSamples=0;
+ unsigned long frameSamples = 0;
unsigned char *buf = NULL;
- unsigned char* v2TagExistCheck = NULL;
+ unsigned char *v2TagExistCheck = NULL;
int readAmount = 0, readedDataLen = 0;
unsigned char TagBuff[MP3TAGINFO_SIZE + TAGV1_SEEK_GAP];
- unsigned char TagV1ID[4] = { 0x54, 0x41, 0x47}; //TAG
+ unsigned char TagV1ID[4] = { 0x54, 0x41, 0x47}; /*TAG */
int tagHeaderPos = 0;
int ret = 0;
unsigned int head_offset = 0;
if (pInfo == NULL || filename == NULL)
return -1;
- memset( pInfo, 0x00, sizeof(AvFileContentInfo) );
+ memset(pInfo, 0x00, sizeof(AvFileContentInfo));
pInfo->tagV2Info.tagLen = 0;
pInfo->headerPos = 0;
pInfo->genre = 148;
/*open*/
- ret = mmfile_open (&hFile, filename, MMFILE_RDONLY);
- if (ret == MMFILE_UTIL_FAIL)
- {
- debug_error ( "open failed.\n");
+ ret = mmfile_open(&hFile, filename, MMFILE_RDONLY);
+ if (ret == MMFILE_UTIL_FAIL) {
+ debug_error("open failed.\n");
return -1;
}
- mmfile_seek (hFile, 0L, SEEK_END);
- pInfo->fileLen = mmfile_tell (hFile);
- if (pInfo->fileLen <= 0)
- {
- debug_error ( "file is too small.\n");
+ mmfile_seek(hFile, 0L, SEEK_END);
+ pInfo->fileLen = mmfile_tell(hFile);
+ if (pInfo->fileLen <= 0) {
+ debug_error("file is too small.\n");
goto EXCEPTION;
}
- mmfile_seek (hFile, 0L, SEEK_SET);
+ mmfile_seek(hFile, 0L, SEEK_SET);
- v2TagExistCheck = mmfile_malloc (MP3_TAGv2_HEADER_LEN);
+ v2TagExistCheck = mmfile_malloc(MP3_TAGv2_HEADER_LEN);
if (v2TagExistCheck == NULL) {
- debug_error ( "malloc failed.\n");
+ debug_error("malloc failed.\n");
goto EXCEPTION;
}
- if (mmfile_read (hFile, v2TagExistCheck, MP3_TAGv2_HEADER_LEN) > 0)
- {
- if(IS_ID3V2_TAG(v2TagExistCheck))
- {
- if(!(v2TagExistCheck[3] == 0xFF || v2TagExistCheck[4] == 0xFF ||v2TagExistCheck[6] >= 0x80 || v2TagExistCheck[7] >= 0x80 || v2TagExistCheck[8] >= 0x80 || v2TagExistCheck[9] >= 0x80))
- {
- if(!(v2TagExistCheck[3] > 0x04))
- {
+ if (mmfile_read(hFile, v2TagExistCheck, MP3_TAGv2_HEADER_LEN) > 0) {
+ if (IS_ID3V2_TAG(v2TagExistCheck)) {
+ if (!(v2TagExistCheck[3] == 0xFF || v2TagExistCheck[4] == 0xFF || v2TagExistCheck[6] >= 0x80 || v2TagExistCheck[7] >= 0x80 || v2TagExistCheck[8] >= 0x80 || v2TagExistCheck[9] >= 0x80)) {
+ if (!(v2TagExistCheck[3] > 0x04)) {
pInfo->tagV2Info.tagVersion = v2TagExistCheck[3];
pInfo->tagV2Info.tagLen = MP3_TAGv2_HEADER_LEN;
- pInfo->tagV2Info.tagLen += (unsigned long)v2TagExistCheck[6] << 21 | (unsigned long)v2TagExistCheck[7] << 14 |(unsigned long)v2TagExistCheck[8] << 7 | (unsigned long)v2TagExistCheck[9];
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->tagV2Info.tagLen(%d), pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagLen, pInfo->tagV2Info.tagVersion);
- #endif
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tag is a not supported version(%d)\n", v2TagExistCheck[3]);
- #endif
+ pInfo->tagV2Info.tagLen += (unsigned long)v2TagExistCheck[6] << 21 | (unsigned long)v2TagExistCheck[7] << 14 | (unsigned long)v2TagExistCheck[8] << 7 | (unsigned long)v2TagExistCheck[9];
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->tagV2Info.tagLen(%d), pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagLen, pInfo->tagV2Info.tagVersion);
+#endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tag is a not supported version(%d)\n", v2TagExistCheck[3]);
+#endif
}
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tag is a tag data is valid.\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tag is a tag data is valid.\n");
- #endif
- }
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "this mp3 file is not included ID3v2 tag info!\n");
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("this mp3 file is not included ID3v2 tag info!\n");
+#endif
}
- }
- else
- {
- debug_error ( "v2TagExistCheck value read fail!\n");
- if(v2TagExistCheck)
+ } else {
+ debug_error("v2TagExistCheck value read fail!\n");
+ if (v2TagExistCheck)
_FREE_EX(v2TagExistCheck);
goto EXCEPTION;
}
- if(v2TagExistCheck)
+ if (v2TagExistCheck)
_FREE_EX(v2TagExistCheck);
- if(!(pInfo->fileLen > pInfo->tagV2Info.tagLen ))
+ if (!(pInfo->fileLen > pInfo->tagV2Info.tagLen))
pInfo->tagV2Info.tagLen = 0;
if (mmfile_seek(hFile, 0L, SEEK_SET) < 0)
goto EXCEPTION;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->fileLen(%lld)\n", pInfo->fileLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->fileLen(%lld)\n", pInfo->fileLen);
+#endif
- if(pInfo->fileLen > (_AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen))
- {
+ if (pInfo->fileLen > (_AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen)) {
readAmount = _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen;
- buf = mmfile_malloc (readAmount);
+ buf = mmfile_malloc(readAmount);
if (buf == NULL) {
- debug_error ( "malloc failed.\n");
+ debug_error("malloc failed.\n");
goto EXCEPTION;
}
- while(readAmount > 0)
- {
- if(readAmount >= AV_MP3_HEADER_READ_MAX)
- {
+ while (readAmount > 0) {
+ if (readAmount >= AV_MP3_HEADER_READ_MAX) {
if ((readedDataLen <= _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen)
- &&(mmfile_read(hFile, buf+readedDataLen, AV_MP3_HEADER_READ_MAX) <= 0))
- {
- if(buf)
+ && (mmfile_read(hFile, buf + readedDataLen, AV_MP3_HEADER_READ_MAX) <= 0)) {
+ if (buf)
_FREE_EX(buf);
-
+
goto EXCEPTION;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Reading buf readedDataLen(%d) readAmount (%d)\n", readedDataLen, readAmount);
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Reading buf readedDataLen(%d) readAmount (%d)\n", readedDataLen,readAmount);
- #endif
- }
- }
- else
- {
+ } else {
if ((readedDataLen <= _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen)
- &&(mmfile_read(hFile, buf+readedDataLen, readAmount) <= 0))
- {
- if(buf)
+ && (mmfile_read(hFile, buf + readedDataLen, readAmount) <= 0)) {
+ if (buf)
_FREE_EX(buf);
-
+
goto EXCEPTION;
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "The remained buf readed! readedDataLen(%d) readAmount (%d)\n", readedDataLen,readAmount);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("The remained buf readed! readedDataLen(%d) readAmount (%d)\n", readedDataLen, readAmount);
+#endif
}
}
readAmount -= AV_MP3_HEADER_READ_MAX;
readedDataLen += AV_MP3_HEADER_READ_MAX;
-
- if(readAmount <= 0)
+
+ if (readAmount <= 0)
break;
}
- }
- else
- {
- buf = mmfile_malloc (pInfo->fileLen);
- if (buf == NULL)
- {
- goto EXCEPTION;
+ } else {
+ buf = mmfile_malloc(pInfo->fileLen);
+ if (buf == NULL) {
+ goto EXCEPTION;
}
- if (mmfile_read(hFile, buf, pInfo->fileLen) <= 0)
- {
- if(buf)
+ if (mmfile_read(hFile, buf, pInfo->fileLen) <= 0) {
+ if (buf)
_FREE_EX(buf);
goto EXCEPTION;
}
}
-
- if (__AvGetLastID3offset (hFile, &head_offset)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "search start offset: %u\n", head_offset);
- #endif
+
+ if (__AvGetLastID3offset(hFile, &head_offset)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("search start offset: %u\n", head_offset);
+#endif
pInfo->tagV2Info.tagLen = head_offset;
}
-
+
pInfo->headerPos = (long) __AvFindStartOfMp3Header(hFile, buf, pInfo);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Pos: %ld\n", pInfo->headerPos);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Pos: %ld\n", pInfo->headerPos);
+#endif
- if(buf)
+ if (buf)
_FREE_EX(buf);
if (pInfo->headerPos == -1)
if (mmfile_seek(hFile, pInfo->headerPos, SEEK_SET) < 0)
goto EXCEPTION;
- if (mmfile_read (hFile, header, 256) <= 0)
+ if (mmfile_read(hFile, header, 256) <= 0)
goto EXCEPTION;
- if ( __AvParseMp3Header( pInfo, header ) == false)
+ if (__AvParseMp3Header(pInfo, header) == false)
goto EXCEPTION;
- if ( __AvParseXingHeader( pInfo, header ) )
- {
- __AvGetXingBitrate( pInfo );
- }
- else if(__AvParseVBRIHeader( pInfo, header ))
- {
- __AvGetVBRIBitrate( pInfo );
- }
- else
- {
- __AvGetMp3FrameSize( pInfo );
+ if (__AvParseXingHeader(pInfo, header)) {
+ __AvGetXingBitrate(pInfo);
+ } else if (__AvParseVBRIHeader(pInfo, header)) {
+ __AvGetVBRIBitrate(pInfo);
+ } else {
+ __AvGetMp3FrameSize(pInfo);
pInfo->datafileLen = pInfo->fileLen - pInfo->headerPos;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Mp3 File FrameSize (%d) pInfo->headerPos(%d)\n", pInfo->frameSize,pInfo->headerPos);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Mp3 File FrameSize (%d) pInfo->headerPos(%d)\n", pInfo->frameSize, pInfo->headerPos);
+#endif
}
- if (mmfile_seek (hFile, -(MP3TAGINFO_SIZE + TAGV1_SEEK_GAP), SEEK_END) < 0)
+ if (mmfile_seek(hFile, -(MP3TAGINFO_SIZE + TAGV1_SEEK_GAP), SEEK_END) < 0)
goto EXCEPTION;
- pInfo ->bV1tagFound = false;
+ pInfo->bV1tagFound = false;
- if (mmfile_read (hFile, TagBuff, MP3TAGINFO_SIZE + TAGV1_SEEK_GAP) <= 0)
+ if (mmfile_read(hFile, TagBuff, MP3TAGINFO_SIZE + TAGV1_SEEK_GAP) <= 0)
goto EXCEPTION;
- if ((tagHeaderPos = __AvMemstr(TagBuff, TagV1ID, 3, TAGV1_SEEK_GAP+5)) >= 0)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Mp3 File Tag is existing\n");
- #endif
-
- pInfo ->bV1tagFound = true;
- /* In this case, V2 Tag alreay exist So, ignore V1 tag */
- if (pInfo->tagV2Info.tagLen == 0) {
- memcpy(TagBuff, (TagBuff + tagHeaderPos), MP3TAGINFO_SIZE);
- if(!mm_file_id3tag_parse_v110(pInfo, TagBuff))
- goto EXCEPTION;
- }
+ if ((tagHeaderPos = __AvMemstr(TagBuff, TagV1ID, 3, TAGV1_SEEK_GAP + 5)) >= 0) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Mp3 File Tag is existing\n");
+#endif
+
+ pInfo->bV1tagFound = true;
+ /* In this case, V2 Tag alreay exist So, ignore V1 tag */
+ if (pInfo->tagV2Info.tagLen == 0) {
+ memcpy(TagBuff, (TagBuff + tagHeaderPos), MP3TAGINFO_SIZE);
+ if (!mm_file_id3tag_parse_v110(pInfo, TagBuff))
+ goto EXCEPTION;
}
+ }
- mm_file_id3tag_restore_content_info (pInfo);
+ mm_file_id3tag_restore_content_info(pInfo);
- if(pInfo->mpegVersion== 1)
- {
- if(pInfo->layer== 1)
+ if (pInfo->mpegVersion == 1) {
+ if (pInfo->layer == 1)
frameSamples = MPEG_1_SIZE_LAYER_1;
else
frameSamples = MPEG_1_SIZE_LAYER_2_3;
- }
- else
- {
- if(pInfo->layer == 1)
+ } else {
+ if (pInfo->layer == 1)
frameSamples = MPEG_2_SIZE_LAYER_1;
else
frameSamples = MPEG_2_SIZE_LAYER_2_3;
}
#if 0
- unsigned long numOfFrames=0;
+ unsigned long numOfFrames = 0;
unsigned long long tempduration = 0;
unsigned int tempNumFrames = 0;
- if(pInfo->bVbr)
- numOfFrames = pInfo->frameNum*10;
- else
- {
+ if (pInfo->bVbr)
+ numOfFrames = pInfo->frameNum * 10;
+ else {
numOfFrames = ((pInfo->fileLen
- -(pInfo->headerPos + (pInfo ->bV1tagFound ? MP3TAGINFO_SIZE : 0) ) )*10) / pInfo->frameSize;
- }
- tempNumFrames = (unsigned int)(numOfFrames/10);
+ - (pInfo->headerPos + (pInfo->bV1tagFound ? MP3TAGINFO_SIZE : 0))) * 10) / pInfo->frameSize;
+ }
+ tempNumFrames = (unsigned int)(numOfFrames / 10);
- if((numOfFrames - tempNumFrames * 10 ) > 5)
- numOfFrames = (numOfFrames/10) + 1;
+ if ((numOfFrames - tempNumFrames * 10) > 5)
+ numOfFrames = (numOfFrames / 10) + 1;
else
- numOfFrames = numOfFrames/10;
+ numOfFrames = numOfFrames / 10;
- tempduration = (unsigned long long)(numOfFrames *1000);
+ tempduration = (unsigned long long)(numOfFrames * 1000);
- if(pInfo->mpegVersion== 1)
- {
- if(pInfo->layer== 1)
+ if (pInfo->mpegVersion == 1) {
+ if (pInfo->layer == 1)
frameSamples = MPEG_1_SIZE_LAYER_1;
else
frameSamples = MPEG_1_SIZE_LAYER_2_3;
- }
- else
- {
- if(pInfo->layer == 1)
+ } else {
+ if (pInfo->layer == 1)
frameSamples = MPEG_2_SIZE_LAYER_1;
else
frameSamples = MPEG_2_SIZE_LAYER_2_3;
debug_msg("frameSamples : %d, tempduration : %ld", frameSamples, tempduration);
#endif
- if(tempduration < (unsigned long long)pInfo->sampleRate)
- {
- tempduration = (tempduration*frameSamples*10)/pInfo->sampleRate;
- tempduration = (tempduration/10);
- }
- else
- tempduration = (tempduration*frameSamples)/pInfo->sampleRate;
+ if (tempduration < (unsigned long long)pInfo->sampleRate) {
+ tempduration = (tempduration * frameSamples * 10) / pInfo->sampleRate;
+ tempduration = (tempduration / 10);
+ } else
+ tempduration = (tempduration * frameSamples) / pInfo->sampleRate;
pInfo->duration = tempduration;
#else
- if(pInfo->bVbr) {
- pInfo->duration = ((double)(frameSamples * 1000) / pInfo->sampleRate) * pInfo->frameNum;
+ if (pInfo->bVbr) {
+ pInfo->duration = ((double)(frameSamples * 1000) / pInfo->sampleRate) * pInfo->frameNum;
debug_msg("duration for VBR : %lld", pInfo->duration);
} else {
unsigned long long frame_duration = (((unsigned long long)frameSamples * 1000000000) / pInfo->sampleRate / 1000);
int file_size_except_header = pInfo->fileLen - (pInfo->headerPos + (pInfo->bV1tagFound ? MP3TAGINFO_SIZE : 0));
pInfo->duration = ((double)file_size_except_header / (double)pInfo->frameSize) * frame_duration / 1000;
- //pInfo->duration = ((double)file_size_except_header / (double)pInfo->frameSize) * (frameSamples * 1000 / pInfo->sampleRate);
+ /*pInfo->duration = ((double)file_size_except_header / (double)pInfo->frameSize) * (frameSamples * 1000 / pInfo->sampleRate); */
debug_msg("duration from new algorithm : %lld", pInfo->duration);
}
#endif
mmfile_close(hFile);
/*debug print*/
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Mp3 File pInfo->duration (%lld) \n", pInfo->duration);
- debug_msg ( "** MP3 **\n");
- debug_msg ( "Version : %u\n", pInfo->mpegVersion);
- debug_msg ( "Layer : %u\n", pInfo->layer);
- debug_msg ( "Channel idx: %u\n", pInfo->channelIndex);
- debug_msg ( "Is VBR : %d\n", (pInfo->bVbr == true ? 1 : 0));
- debug_msg ( "Bitrate : %u\n", pInfo->bitRate);
- debug_msg ( "SampleRate : %u\n", pInfo->sampleRate);
- debug_msg ( "Channels : %u\n", pInfo->channels);
- debug_msg ( "**** Info #1 ****\n");
- debug_msg ( "Title : %s\n", pInfo->pTitle);
- debug_msg ( "Artist : %s\n", pInfo->pArtist);
- debug_msg ( "Album : %s\n", pInfo->pAlbum);
- debug_msg ( "Album_Artist: %s\n", pInfo->pAlbum_Artist);
- debug_msg ( "Year : %s\n", pInfo->pYear);
- debug_msg ( "Comment : %s\n", pInfo->pComment);
- debug_msg ( "TrackNum : %s\n", pInfo->pTrackNum);
- debug_msg ( "Genre : %s\n", pInfo->pGenre);
- debug_msg ( "**** Info #2 ****\n");
- debug_msg ( "Author : %s\n", pInfo->pAuthor);
- debug_msg ( "Copyright : %s\n", pInfo->pCopyright);
- debug_msg ( "Comment : %s\n", pInfo->pComment);
- debug_msg ( "Rating : %s\n", pInfo->pRating);
- debug_msg ( "RecDate : %s\n", pInfo->pRecDate);
- debug_msg ( "Encoded by : %s\n", pInfo->pEncBy);
- debug_msg ( "URL : %s\n", pInfo->pURL);
- debug_msg ( "Ori. Artist : %s\n", pInfo->pOriginArtist);
- debug_msg ( "Composer : %s\n", pInfo->pComposer);
- debug_msg ( "Conductor : %s\n", pInfo->pConductor);
- debug_msg ( "Artwork : mime(%s) addr(%p) size(%d)\n", pInfo->imageInfo.imageMIMEType, pInfo->imageInfo.pImageBuf, pInfo->imageInfo.imageLen);
- debug_msg ( "UnsyncLyrics : %s\n", pInfo->pUnsyncLyrics);
- debug_msg ( "SyncLyrics size : %d\n", pInfo->syncLyricsNum);
-
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Mp3 File pInfo->duration (%lld) \n", pInfo->duration);
+ debug_msg("** MP3 **\n");
+ debug_msg("Version : %u\n", pInfo->mpegVersion);
+ debug_msg("Layer : %u\n", pInfo->layer);
+ debug_msg("Channel idx: %u\n", pInfo->channelIndex);
+ debug_msg("Is VBR : %d\n", (pInfo->bVbr == true ? 1 : 0));
+ debug_msg("Bitrate : %u\n", pInfo->bitRate);
+ debug_msg("SampleRate : %u\n", pInfo->sampleRate);
+ debug_msg("Channels : %u\n", pInfo->channels);
+ debug_msg("**** Info #1 ****\n");
+ debug_msg("Title : %s\n", pInfo->pTitle);
+ debug_msg("Artist : %s\n", pInfo->pArtist);
+ debug_msg("Album : %s\n", pInfo->pAlbum);
+ debug_msg("Album_Artist: %s\n", pInfo->pAlbum_Artist);
+ debug_msg("Year : %s\n", pInfo->pYear);
+ debug_msg("Comment : %s\n", pInfo->pComment);
+ debug_msg("TrackNum : %s\n", pInfo->pTrackNum);
+ debug_msg("Genre : %s\n", pInfo->pGenre);
+ debug_msg("**** Info #2 ****\n");
+ debug_msg("Author : %s\n", pInfo->pAuthor);
+ debug_msg("Copyright : %s\n", pInfo->pCopyright);
+ debug_msg("Comment : %s\n", pInfo->pComment);
+ debug_msg("Rating : %s\n", pInfo->pRating);
+ debug_msg("RecDate : %s\n", pInfo->pRecDate);
+ debug_msg("Encoded by : %s\n", pInfo->pEncBy);
+ debug_msg("URL : %s\n", pInfo->pURL);
+ debug_msg("Ori. Artist : %s\n", pInfo->pOriginArtist);
+ debug_msg("Composer : %s\n", pInfo->pComposer);
+ debug_msg("Conductor : %s\n", pInfo->pConductor);
+ debug_msg("Artwork : mime(%s) addr(%p) size(%d)\n", pInfo->imageInfo.imageMIMEType, pInfo->imageInfo.pImageBuf, pInfo->imageInfo.imageLen);
+ debug_msg("UnsyncLyrics : %s\n", pInfo->pUnsyncLyrics);
+ debug_msg("SyncLyrics size : %d\n", pInfo->syncLyricsNum);
+
+#endif
return 0;
EXCEPTION:
- debug_error ("Error occured!\n");
+ debug_error("Error occured!\n");
mmfile_close(hFile);
return -1;
}
#define MMFILE_ID3V1TAG_SIZE 128
#define MMFILE_ID3V2TAG_HEADER_SIZE 10
-static unsigned int GetSynchsafeInteger (unsigned int value);
+static unsigned int GetSynchsafeInteger(unsigned int value);
EXPORT_API
-int MMFileID3V1TagFind (MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out)
+int MMFileID3V1TagFind(MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out)
{
- int ret = 0;
-
- if (!fp || !out)
- {
- debug_error ("Invalid input\n");
- return MMFILE_ID3TAG_FAIL;
- }
-
- if (bAppended)
- {
- unsigned char tagSymbol[3] = {0,};
-
- unsigned int offset = endOffset - MMFILE_ID3V1TAG_SIZE;
-
- mmfile_seek (fp, offset, MMFILE_SEEK_SET);
-
- ret = mmfile_read (fp, tagSymbol, 3);
- if (MMFILE_UTIL_FAIL == ret)
- {
- debug_error ("read error\n");
- return MMFILE_ID3TAG_FAIL;
- }
-
- if (memcmp ("TAG", tagSymbol, 3) == 0)
- {
- unsigned char versionBuf[2] = {0,};
-
- out->typeOfTag = MMFILE_TAG_ID3V1;
- out->startOffset = offset;
- out->endOffset = endOffset;
- out->bAppendedTag = 1;
- out->tagSize = MMFILE_ID3V1TAG_SIZE;
-
- offset += 125; // byte delimiter offset: ID3V1.1 spec.
- mmfile_seek (fp, offset, MMFILE_SEEK_SET);
-
- ret = mmfile_read (fp, versionBuf, 2);
- if (MMFILE_UTIL_FAIL == ret)
- {
- debug_error ("read error\n");
- return MMFILE_ID3TAG_FAIL;
- }
-
- if (versionBuf[0] == '\0' && versionBuf[1] != '\0')
- {
- out->version = MMFILE_ID3TAG_V1_1;
- }
- else
- {
- out->version = MMFILE_ID3TAG_V1_0;
- }
-
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("typeOfTag = %d\n", out->typeOfTag);
- debug_msg ("startOffset = %d\n", out->startOffset);
- debug_msg ("endOffset = %d\n", out->endOffset);
- debug_msg ("bAppendedTag = %d\n", out->bAppendedTag);
- debug_msg ("tagSize = %d\n", out->tagSize);
- debug_msg ("version = %d\n", out->version);
- #endif
-
- return MMFILE_ID3TAG_SUCCESS;
- }
- }
-
- return MMFILE_ID3TAG_FAIL;
+ int ret = 0;
+
+ if (!fp || !out) {
+ debug_error("Invalid input\n");
+ return MMFILE_ID3TAG_FAIL;
+ }
+
+ if (bAppended) {
+ unsigned char tagSymbol[3] = {0, };
+
+ unsigned int offset = endOffset - MMFILE_ID3V1TAG_SIZE;
+
+ mmfile_seek(fp, offset, MMFILE_SEEK_SET);
+
+ ret = mmfile_read(fp, tagSymbol, 3);
+ if (MMFILE_UTIL_FAIL == ret) {
+ debug_error("read error\n");
+ return MMFILE_ID3TAG_FAIL;
+ }
+
+ if (memcmp("TAG", tagSymbol, 3) == 0) {
+ unsigned char versionBuf[2] = {0, };
+
+ out->typeOfTag = MMFILE_TAG_ID3V1;
+ out->startOffset = offset;
+ out->endOffset = endOffset;
+ out->bAppendedTag = 1;
+ out->tagSize = MMFILE_ID3V1TAG_SIZE;
+
+ offset += 125; /* byte delimiter offset: ID3V1.1 spec. */
+ mmfile_seek(fp, offset, MMFILE_SEEK_SET);
+
+ ret = mmfile_read(fp, versionBuf, 2);
+ if (MMFILE_UTIL_FAIL == ret) {
+ debug_error("read error\n");
+ return MMFILE_ID3TAG_FAIL;
+ }
+
+ if (versionBuf[0] == '\0' && versionBuf[1] != '\0') {
+ out->version = MMFILE_ID3TAG_V1_1;
+ } else {
+ out->version = MMFILE_ID3TAG_V1_0;
+ }
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("typeOfTag = %d\n", out->typeOfTag);
+ debug_msg("startOffset = %d\n", out->startOffset);
+ debug_msg("endOffset = %d\n", out->endOffset);
+ debug_msg("bAppendedTag = %d\n", out->bAppendedTag);
+ debug_msg("tagSize = %d\n", out->tagSize);
+ debug_msg("version = %d\n", out->version);
+#endif
+
+ return MMFILE_ID3TAG_SUCCESS;
+ }
+ }
+
+ return MMFILE_ID3TAG_FAIL;
}
EXPORT_API
-int MMFileID3V2TagFind (MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out)
+int MMFileID3V2TagFind(MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out)
{
- unsigned char *id3v2ID = NULL;
- unsigned char header[MMFILE_ID3V2TAG_HEADER_SIZE] = {0,};
- unsigned int offset = 0;
- unsigned int index = 0;
- int ret = 0;
-
- if (!fp || !out)
- {
- debug_error ("Invalid input\n");
- return MMFILE_ID3TAG_FAIL;
- }
-
- if (bAppended)
- {
- id3v2ID = "3DI";
- offset = endOffset - MMFILE_ID3V2TAG_HEADER_SIZE;
- }
- else
- {
- id3v2ID = "ID3";
- offset = startOffset;
- }
-
- mmfile_seek (fp, offset, MMFILE_SEEK_SET);
-
- ret = mmfile_read (fp, header, MMFILE_ID3V2TAG_HEADER_SIZE);
- if (MMFILE_UTIL_FAIL == ret)
- {
- debug_error ("read error\n");
- return MMFILE_ID3TAG_FAIL;
- }
-
- if (memcmp (id3v2ID, header, 3) == 0)
- {
- index += 3;
- out->typeOfTag = MMFILE_TAG_ID3V2;
- out->bAppendedTag = bAppended;
- out->startOffset = offset;
-
- //version check
- switch (header[index])
- {
- case 0:
- out->version = MMFILE_ID3TAG_V2_0;
- break;
- case 2:
- out->version = MMFILE_ID3TAG_V2_2;
- break;
- case 3:
- out->version = MMFILE_ID3TAG_V2_3;
- break;
- case 4:
- out->version = MMFILE_ID3TAG_V2_4;
- break;
- default:
- debug_warning ("unknown version of id3v2\n");
- break;
- }
-
- index += 2;
- //check footer
- unsigned char footer = (header[index] & 0x10) ? 1 : 0;
-
- index += 1;
- //out->tagSize = GetSynchsafeInteger () + (footer ? 20 : 10)
-
- if (bAppended)
- {
-// out->endOffset
- }
- out->endOffset = endOffset;
- }
-
-
- return MMFILE_ID3TAG_FAIL;
+ unsigned char *id3v2ID = NULL;
+ unsigned char header[MMFILE_ID3V2TAG_HEADER_SIZE] = {0, };
+ unsigned int offset = 0;
+ unsigned int index = 0;
+ int ret = 0;
+
+ if (!fp || !out) {
+ debug_error("Invalid input\n");
+ return MMFILE_ID3TAG_FAIL;
+ }
+
+ if (bAppended) {
+ id3v2ID = "3DI";
+ offset = endOffset - MMFILE_ID3V2TAG_HEADER_SIZE;
+ } else {
+ id3v2ID = "ID3";
+ offset = startOffset;
+ }
+
+ mmfile_seek(fp, offset, MMFILE_SEEK_SET);
+
+ ret = mmfile_read(fp, header, MMFILE_ID3V2TAG_HEADER_SIZE);
+ if (MMFILE_UTIL_FAIL == ret) {
+ debug_error("read error\n");
+ return MMFILE_ID3TAG_FAIL;
+ }
+
+ if (memcmp(id3v2ID, header, 3) == 0) {
+ index += 3;
+ out->typeOfTag = MMFILE_TAG_ID3V2;
+ out->bAppendedTag = bAppended;
+ out->startOffset = offset;
+
+ /*version check */
+ switch (header[index]) {
+ case 0:
+ out->version = MMFILE_ID3TAG_V2_0;
+ break;
+ case 2:
+ out->version = MMFILE_ID3TAG_V2_2;
+ break;
+ case 3:
+ out->version = MMFILE_ID3TAG_V2_3;
+ break;
+ case 4:
+ out->version = MMFILE_ID3TAG_V2_4;
+ break;
+ default:
+ debug_warning("unknown version of id3v2\n");
+ break;
+ }
+
+ index += 2;
+ /*check footer */
+ unsigned char footer = (header[index] & 0x10) ? 1 : 0;
+
+ index += 1;
+ /*out->tagSize = GetSynchsafeInteger() + (footer ? 20 : 10) */
+
+ if (bAppended) {
+/* out->endOffset */
+ }
+ out->endOffset = endOffset;
+ }
+
+
+ return MMFILE_ID3TAG_FAIL;
}
-static unsigned int GetSynchsafeInteger (unsigned int value)
+static unsigned int GetSynchsafeInteger(unsigned int value)
{
- int i = 0;
- const unsigned int mask = 0x7F000000;
- unsigned int ret = 0;
-
- for (i = 0; i < sizeof(unsigned int); i++)
- {
- ret = (ret << 7) | ((value & mask) >> 24);
- value <<= 8;
- }
- return ret;
+ int i = 0;
+ const unsigned int mask = 0x7F000000;
+ unsigned int ret = 0;
+
+ for (i = 0; i < sizeof(unsigned int); i++) {
+ ret = (ret << 7) | ((value & mask) >> 24);
+ value <<= 8;
+ }
+ return ret;
}
typedef int (*MMFileFindTagFunc)(MMFileIOHandle *fp, unsigned char bAppended, unsigned int startOffset, unsigned int endOffset, tMMFileTags *out);
-typedef struct mmfiletagsdata
-{
- MMFileIOHandle *fp;
- unsigned int filesize;
- unsigned int startOffset;
- unsigned int endOffset;
- MMFileList tagList;
+typedef struct mmfiletagsdata {
+ MMFileIOHandle *fp;
+ unsigned int filesize;
+ unsigned int startOffset;
+ unsigned int endOffset;
+ MMFileList tagList;
} tMMFileTagsData;
-MMFileFindTagFunc gFindPreprendTagFuncs[] =
-{
- MMFileID3V2TagFind,
+MMFileFindTagFunc gFindPreprendTagFuncs[] = {
+ MMFileID3V2TagFind,
};
-MMFileFindTagFunc gFindAppendTagFuncs[] =
-{
- MMFileID3V1TagFind,
- MMFileID3V2TagFind,
+MMFileFindTagFunc gFindAppendTagFuncs[] = {
+ MMFileID3V1TagFind,
+ MMFileID3V2TagFind,
};
-int _MMFileFindTags (tMMFileTagsData *privateData, MMFileFindTagFunc FindTag, unsigned char bAppended);
-int _MMFileFindPrependTags (tMMFileTagsData *privateData);
-int _MMFileFindAppendTags (tMMFileTagsData *privateData);
+int _MMFileFindTags(tMMFileTagsData *privateData, MMFileFindTagFunc FindTag, unsigned char bAppended);
+int _MMFileFindPrependTags(tMMFileTagsData *privateData);
+int _MMFileFindAppendTags(tMMFileTagsData *privateData);
EXPORT_API
-int MMFileOpenTags (MMFileTagsHandle *tagsHandle, const char *uriName)
+int MMFileOpenTags(MMFileTagsHandle *tagsHandle, const char *uriName)
{
- tMMFileTagsData *privateData = NULL;
- int ret = 0;
-
- privateData = mmfile_malloc (sizeof(tMMFileTagsData));
- if (!privateData)
- {
- debug_error ("mmfile_malloc: tMMFileTagsData\n");
- return MMFILE_TAGS_FAIL;
- }
-
- *tagsHandle = privateData;
-
- ret = mmfile_open (&privateData->fp, uriName, MMFILE_RDONLY);
- if (MMFILE_UTIL_FAIL == ret)
- {
- debug_error ("mmfile_open\n");
- ret = MMFILE_TAGS_FAIL;
- goto exception;
- }
-
- ret = mmfile_seek (privateData->fp, 0, MMFILE_SEEK_END);
- if (MMFILE_UTIL_FAIL == ret)
- {
- debug_error ("mmfile_seek\n");
- ret = MMFILE_TAGS_FAIL;
- goto exception;
- }
-
- privateData->filesize = mmfile_tell (privateData->fp);
-
- mmfile_seek (privateData->fp, 0, MMFILE_SEEK_SET);
-
- privateData->startOffset = 0;
- privateData->endOffset = privateData->filesize;
-
- /* Find all of tags */
- while (MMFILE_TAGS_SUCCESS == _MMFileFindPrependTags (privateData)) ;
- while (MMFILE_TAGS_SUCCESS == _MMFileFindAppendTags (privateData)) ;
-
- if (!privateData->tagList)
- {
- debug_error ("there is no tags\n");
- ret = MMFILE_TAGS_FAIL;
- goto exception;
- }
-
- return MMFILE_TAGS_SUCCESS;
+ tMMFileTagsData *privateData = NULL;
+ int ret = 0;
+
+ privateData = mmfile_malloc(sizeof(tMMFileTagsData));
+ if (!privateData) {
+ debug_error("mmfile_malloc: tMMFileTagsData\n");
+ return MMFILE_TAGS_FAIL;
+ }
+
+ *tagsHandle = privateData;
+
+ ret = mmfile_open(&privateData->fp, uriName, MMFILE_RDONLY);
+ if (MMFILE_UTIL_FAIL == ret) {
+ debug_error("mmfile_open\n");
+ ret = MMFILE_TAGS_FAIL;
+ goto exception;
+ }
+
+ ret = mmfile_seek(privateData->fp, 0, MMFILE_SEEK_END);
+ if (MMFILE_UTIL_FAIL == ret) {
+ debug_error("mmfile_seek\n");
+ ret = MMFILE_TAGS_FAIL;
+ goto exception;
+ }
+
+ privateData->filesize = mmfile_tell(privateData->fp);
+
+ mmfile_seek(privateData->fp, 0, MMFILE_SEEK_SET);
+
+ privateData->startOffset = 0;
+ privateData->endOffset = privateData->filesize;
+
+ /* Find all of tags */
+ while (MMFILE_TAGS_SUCCESS == _MMFileFindPrependTags(privateData)) ;
+ while (MMFILE_TAGS_SUCCESS == _MMFileFindAppendTags(privateData)) ;
+
+ if (!privateData->tagList) {
+ debug_error("there is no tags\n");
+ ret = MMFILE_TAGS_FAIL;
+ goto exception;
+ }
+
+ return MMFILE_TAGS_SUCCESS;
exception:
- if (*tagsHandle)
- {
- MMFileTagsClose (*tagsHandle);
- *tagsHandle = NULL;
- }
-
- return ret;
+ if (*tagsHandle) {
+ MMFileTagsClose(*tagsHandle);
+ *tagsHandle = NULL;
+ }
+
+ return ret;
}
EXPORT_API
-int MMFileTagsClose (MMFileTagsHandle tagsHandle)
+int MMFileTagsClose(MMFileTagsHandle tagsHandle)
{
- tMMFileTagsData *privateData = tagsHandle;
+ tMMFileTagsData *privateData = tagsHandle;
- if (privateData)
- {
- if (privateData->fp)
- {
- mmfile_close (privateData->fp);
- }
+ if (privateData) {
+ if (privateData->fp) {
+ mmfile_close(privateData->fp);
+ }
- if (privateData->tagList)
- {
- mmfile_free (privateData->tagList);
- }
+ if (privateData->tagList) {
+ mmfile_free(privateData->tagList);
+ }
- mmfile_free (privateData);
- }
+ mmfile_free(privateData);
+ }
- return MMFILE_TAGS_SUCCESS;
+ return MMFILE_TAGS_SUCCESS;
}
EXPORT_API
-int MMFileGetFirstTag (MMFileTagsHandle tagsHandle, tMMFileTags *out)
+int MMFileGetFirstTag(MMFileTagsHandle tagsHandle, tMMFileTags *out)
{
-
+
}
EXPORT_API
-int MMFileGetNextTag (MMFileTagsHandle tagsHandle, tMMFileTags *out)
+int MMFileGetNextTag(MMFileTagsHandle tagsHandle, tMMFileTags *out)
{
}
-int _MMFileFindPrependTags (tMMFileTagsData *privateData)
+int _MMFileFindPrependTags(tMMFileTagsData *privateData)
{
- int i = 0;
- int res = 0;
-
- if (!privateData || !privateData->fp)
- {
- debug_error ("Invalid argument\n");
- return MMFILE_TAGS_FAIL;
- }
-
- for (i = 0; i < MMFILE_TAGS_NUMBER_OF_ELEMENTS(gFindPreprendTagFuncs); i++)
- {
- if (gFindPreprendTagFuncs[i])
- {
- if (MMFILE_TAGS_SUCCESS == _MMFileFindTags (privateData, gFindPreprendTagFuncs[i], 0))
- {
- return MMFILE_TAGS_SUCCESS;
- }
- }
- }
-
- return MMFILE_TAGS_FAIL;
+ int i = 0;
+ int res = 0;
+
+ if (!privateData || !privateData->fp) {
+ debug_error("Invalid argument\n");
+ return MMFILE_TAGS_FAIL;
+ }
+
+ for (i = 0; i < MMFILE_TAGS_NUMBER_OF_ELEMENTS(gFindPreprendTagFuncs); i++) {
+ if (gFindPreprendTagFuncs[i]) {
+ if (MMFILE_TAGS_SUCCESS == _MMFileFindTags(privateData, gFindPreprendTagFuncs[i], 0)) {
+ return MMFILE_TAGS_SUCCESS;
+ }
+ }
+ }
+
+ return MMFILE_TAGS_FAIL;
}
-int _MMFileFindAppendTags (tMMFileTagsData *privateData)
+int _MMFileFindAppendTags(tMMFileTagsData *privateData)
{
- int i = 0;
- int res = 0;
-
- if (!privateData || !privateData->fp)
- {
- debug_error ("Invalid argument\n");
- return MMFILE_TAGS_FAIL;
- }
-
- for (i = 0; i < MMFILE_TAGS_NUMBER_OF_ELEMENTS(gFindAppendTagFuncs); i++)
- {
- if (gFindAppendTagFuncs[i])
- {
- if (MMFILE_TAGS_SUCCESS == _MMFileFindTags (privateData, gFindAppendTagFuncs[i], 1))
- {
- return MMFILE_TAGS_SUCCESS;
- }
- }
- }
-
- return MMFILE_TAGS_FAIL;
+ int i = 0;
+ int res = 0;
+
+ if (!privateData || !privateData->fp) {
+ debug_error("Invalid argument\n");
+ return MMFILE_TAGS_FAIL;
+ }
+
+ for (i = 0; i < MMFILE_TAGS_NUMBER_OF_ELEMENTS(gFindAppendTagFuncs); i++) {
+ if (gFindAppendTagFuncs[i]) {
+ if (MMFILE_TAGS_SUCCESS == _MMFileFindTags(privateData, gFindAppendTagFuncs[i], 1)) {
+ return MMFILE_TAGS_SUCCESS;
+ }
+ }
+ }
+
+ return MMFILE_TAGS_FAIL;
}
-int _MMFileFindTags (tMMFileTagsData *privateData, MMFileFindTagFunc FindTag, unsigned char bAppended)
+int _MMFileFindTags(tMMFileTagsData *privateData, MMFileFindTagFunc FindTag, unsigned char bAppended)
{
- tMMFileTags *tagData = NULL;
- int ret = 0;
-
- if (!privateData || !privateData->fp)
- {
- debug_error ("Invalid argument\n");
- return MMFILE_TAGS_FAIL;
- }
-
- tagData = mmfile_malloc (sizeof(tMMFileTags));
- if (!tagData)
- {
- debug_error ("mmfile_malloc tagData\n");
- return MMFILE_TAGS_FAIL;
- }
-
- ret = FindTag (privateData->fp, bAppended, privateData->startOffset, privateData->endOffset, tagData);
- if (ret)
- {
- if (bAppended)
- {
- privateData->endOffset = tagData->startOffset;
- }
- else
- {
- privateData->startOffset = tagData->endOffset;
- }
-
- /* add tagData into privateData->tagList */
-
- //privateData->tagList = mmfile_list_append (privateData->tagList, tagData);
-
- ret = MMFILE_TAGS_SUCCESS;
- }
-
- mmfile_free(tagData);
-
- return ret;
+ tMMFileTags *tagData = NULL;
+ int ret = 0;
+
+ if (!privateData || !privateData->fp) {
+ debug_error("Invalid argument\n");
+ return MMFILE_TAGS_FAIL;
+ }
+
+ tagData = mmfile_malloc(sizeof(tMMFileTags));
+ if (!tagData) {
+ debug_error("mmfile_malloc tagData\n");
+ return MMFILE_TAGS_FAIL;
+ }
+
+ ret = FindTag(privateData->fp, bAppended, privateData->startOffset, privateData->endOffset, tagData);
+ if (ret) {
+ if (bAppended) {
+ privateData->endOffset = tagData->startOffset;
+ } else {
+ privateData->startOffset = tagData->endOffset;
+ }
+
+ /* add tagData into privateData->tagList */
+
+ /*privateData->tagList = mmfile_list_append(privateData->tagList, tagData); */
+
+ ret = MMFILE_TAGS_SUCCESS;
+ }
+
+ mmfile_free(tagData);
+
+ return ret;
}
* 32 2 little Block align
* 34 2 little Bit per sample
*/
-
-
+
+
#define MMF_FILE_WAVE_CHUNK_LEN 12
#define MMF_FILE_WAVE_SUBCHUNK_LEN 24
#define MMF_FILE_WAVE_HEADER_LEN (MMF_FILE_WAVE_CHUNK_LEN + MMF_FILE_WAVE_SUBCHUNK_LEN)
char *name; /**< WAVE form wFormatTag ID*/
} MMF_FILE_WAVE_CODEC_NAME;
-MMF_FILE_WAVE_CODEC_NAME g_audio_cdc_tbl [] = {
+MMF_FILE_WAVE_CODEC_NAME g_audio_cdc_tbl[] = {
{ 0x0000, "WAVE_FORMAT_UNKNOWN" },
{ 0x0001, "WAVE_FORMAT_PCM" },
{ 0x0002, "WAVE_FORMAT_ADPCM" },
/* internal */
-static unsigned char *mmf_file_wave_get_header (char *src);
-static int mmf_file_wave_get_info (unsigned char *header, MM_FILE_WAVE_INFO *info);
+static unsigned char *mmf_file_wave_get_header(char *src);
+static int mmf_file_wave_get_info(unsigned char *header, MM_FILE_WAVE_INFO *info);
/* mm plugin porting */
-int mmfile_format_read_stream_wav (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame_wav (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag_wav (MMFileFormatContext *formatContext);
-int mmfile_format_close_wav (MMFileFormatContext *formatContext);
+int mmfile_format_read_stream_wav(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame_wav(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag_wav(MMFileFormatContext *formatContext);
+int mmfile_format_close_wav(MMFileFormatContext *formatContext);
EXPORT_API
-int mmfile_format_open_wav (MMFileFormatContext *formatContext)
+int mmfile_format_open_wav(MMFileFormatContext *formatContext)
{
int ret = 0;
}
if (formatContext->pre_checked == 0) {
- ret = MMFileFormatIsValidWAV (NULL, formatContext->uriFileName);
- if ( ret == 0 )
- {
+ ret = MMFileFormatIsValidWAV(NULL, formatContext->uriFileName);
+ if (ret == 0) {
debug_error("It is not wav file\n");
return MMFILE_FORMAT_FAIL;
}
}
EXPORT_API
-int mmfile_format_read_stream_wav (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream_wav(MMFileFormatContext *formatContext)
{
unsigned char *header = NULL;
MM_FILE_WAVE_INFO *waveinfo = NULL;
return MMFILE_FORMAT_FAIL;
}
- header = mmf_file_wave_get_header (formatContext->uriFileName);
+ header = mmf_file_wave_get_header(formatContext->uriFileName);
if (header == NULL) {
debug_error("error: mmf_file_wave_get_header\n");
goto exception;
}
- waveinfo = mmfile_malloc (sizeof(MM_FILE_WAVE_INFO));
+ waveinfo = mmfile_malloc(sizeof(MM_FILE_WAVE_INFO));
if (waveinfo == NULL) {
debug_error("error: mmfile_malloc\n");
goto exception;
}
- ret = mmf_file_wave_get_info (header, waveinfo);
+ ret = mmf_file_wave_get_info(header, waveinfo);
if (ret == -1) {
debug_error("error: mmf_file_wave_get_info\n");
goto exception;
}
- mmfile_free (header);
+ mmfile_free(header);
- /* Get file size. because sometimes waveinfo->size is wrong */
- ret = mmfile_open (&fp, formatContext->uriFileName, MMFILE_RDONLY);
- if(fp) {
- mmfile_seek (fp, 0, MMFILE_SEEK_END);
+ /* Get file size. because sometimes waveinfo->size is wrong */
+ ret = mmfile_open(&fp, formatContext->uriFileName, MMFILE_RDONLY);
+ if (fp) {
+ mmfile_seek(fp, 0, MMFILE_SEEK_END);
filesize = mmfile_tell(fp);
- mmfile_seek (fp, 0, MMFILE_SEEK_SET);
- mmfile_close (fp);
+ mmfile_seek(fp, 0, MMFILE_SEEK_SET);
+ mmfile_close(fp);
}
formatContext->privateFormatData = waveinfo;
- if(waveinfo->size > filesize) {
+ if (waveinfo->size > filesize) {
/*Wrong information*/
formatContext->duration = (int)((((float)filesize - MMF_FILE_WAVE_HEADER_LEN) / (float)(waveinfo->byte_rate)) * 1000.0F);
} else {
formatContext->audioTotalTrackNum = 1;
formatContext->nbStreams = 1;
- formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc (sizeof(MMFileFormatStream));
+ formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc(sizeof(MMFileFormatStream));
if (!formatContext->streams[MMFILE_AUDIO_STREAM]) {
debug_error("error: mmfile_malloc audio stream for wav\n");
break;
}
- formatContext->streams[MMFILE_AUDIO_STREAM]->bitRate = waveinfo->byte_rate*8;
+ formatContext->streams[MMFILE_AUDIO_STREAM]->bitRate = waveinfo->byte_rate * 8;
formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = waveinfo->channel;
formatContext->streams[MMFILE_AUDIO_STREAM]->framePerSec = 0;
formatContext->streams[MMFILE_AUDIO_STREAM]->samplePerSec = waveinfo->sample_rate;
return MMFILE_FORMAT_SUCCESS;
exception:
- mmfile_free (header);
- mmfile_free (waveinfo);
+ mmfile_free(header);
+ mmfile_free(waveinfo);
return MMFILE_FORMAT_FAIL;
}
EXPORT_API
-int mmfile_format_read_frame_wav (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame_wav(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_read_tag_wav (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag_wav(MMFileFormatContext *formatContext)
{
return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_close_wav (MMFileFormatContext *formatContext)
+int mmfile_format_close_wav(MMFileFormatContext *formatContext)
{
if (formatContext == NULL) {
debug_error("formatContext is NULL\n");
}
if (formatContext->privateFormatData)
- mmfile_free (formatContext->privateFormatData);
+ mmfile_free(formatContext->privateFormatData);
return MMFILE_FORMAT_SUCCESS;
}
-static char*
-_dump_codec_name (short codec)
-{
#ifdef __MMFILE_TEST_MODE__
- int sz = sizeof (g_audio_cdc_tbl) / sizeof (MMF_FILE_WAVE_CODEC_NAME);
+static char *
+_dump_codec_name(short codec)
+{
+ int sz = sizeof(g_audio_cdc_tbl) / sizeof(MMF_FILE_WAVE_CODEC_NAME);
int i;
-
+
for (i = 0; i < sz; i++) {
if (g_audio_cdc_tbl[i].codec == codec) {
return g_audio_cdc_tbl[i].name;
}
}
-#endif
+
return NULL;
}
+#endif
-static int _get_fmt_subchunk_offset (MMFileIOHandle *fp, long long limit, long long *offset)
+static int _get_fmt_subchunk_offset(MMFileIOHandle *fp, long long limit, long long *offset)
{
long long fmt_offset;
int readed;
int i;
unsigned char buf[4];
- fmt_offset = mmfile_tell (fp);
+ fmt_offset = mmfile_tell(fp);
if (fmt_offset < 0)
return 0;
for (i = 0; i < limit; i++) {
- mmfile_seek (fp, fmt_offset + i, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buf, 4);
+ mmfile_seek(fp, fmt_offset + i, MMFILE_SEEK_SET);
+ readed = mmfile_read(fp, buf, 4);
if (readed != 4) {
- debug_error ( "failed to read. size = %d\n", readed);
+ debug_error("failed to read. size = %d\n", readed);
return 0;
}
-
+
if (buf[0] == 'f' && buf[1] == 'm' && buf[2] == 't' && buf[3] == ' ') {
*offset = fmt_offset + i;
return 1;
}
}
-
+
return 0;
}
static unsigned char *
-mmf_file_wave_get_header (char *src)
+mmf_file_wave_get_header(char *src)
{
int readed = 0;
MMFileIOHandle *fp = NULL;
long long offset = 0;
long long limit;
- header = mmfile_malloc (MMF_FILE_WAVE_HEADER_LEN);
+ header = mmfile_malloc(MMF_FILE_WAVE_HEADER_LEN);
if (!header)
return NULL;
/*open*/
- ret = mmfile_open (&fp, src, MMFILE_RDONLY);
+ ret = mmfile_open(&fp, src, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error ( "open failed.\n");
+ debug_error("open failed.\n");
goto failed;
}
/*get file size*/
- mmfile_seek (fp, 0L, MMFILE_SEEK_END);
- src_size = mmfile_tell (fp);
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_END);
+ src_size = mmfile_tell(fp);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (src_size < MMF_FILE_WAVE_HEADER_LEN) {
- debug_error ( "header is too small.\n");
+ debug_error("header is too small.\n");
goto failed;
}
/*read chunk data*/
- readed = mmfile_read (fp, header, MMF_FILE_WAVE_CHUNK_LEN);
+ readed = mmfile_read(fp, header, MMF_FILE_WAVE_CHUNK_LEN);
if (readed != MMF_FILE_WAVE_CHUNK_LEN) {
- debug_error ( "read error. size = %d\n", readed);
+ debug_error("read error. size = %d\n", readed);
goto failed;
}
/*seach 'fmt ' sub chunk*/
limit = (src_size - MMF_FILE_WAVE_HEADER_LEN > 10240 ? 10240 : src_size - MMF_FILE_WAVE_HEADER_LEN);
- ret = _get_fmt_subchunk_offset (fp, limit, &offset);
+ ret = _get_fmt_subchunk_offset(fp, limit, &offset);
if (ret == 0) {
- debug_error ( "failed to seach 'fmt ' chunk\n");
+ debug_error("failed to seach 'fmt ' chunk\n");
goto failed;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("fmt offset: %lld\n", offset);
- #endif
-
- mmfile_seek (fp, offset, MMFILE_SEEK_SET);
-
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("fmt offset: %lld\n", offset);
+#endif
+
+ mmfile_seek(fp, offset, MMFILE_SEEK_SET);
+
/*read sub chunk data*/
- readed = mmfile_read (fp, header + MMF_FILE_WAVE_CHUNK_LEN, MMF_FILE_WAVE_SUBCHUNK_LEN);
+ readed = mmfile_read(fp, header + MMF_FILE_WAVE_CHUNK_LEN, MMF_FILE_WAVE_SUBCHUNK_LEN);
if (readed != MMF_FILE_WAVE_SUBCHUNK_LEN) {
- debug_error ( "read error. size = %d\n", readed);
+ debug_error("read error. size = %d\n", readed);
goto failed;
}
- mmfile_close (fp);
+ mmfile_close(fp);
return header;
failed:
- if (header) mmfile_free (header);
- if (fp) mmfile_close (fp);
+ if (header) mmfile_free(header);
+ if (fp) mmfile_close(fp);
return NULL;
}
static int
-mmf_file_wave_get_info (unsigned char *header, MM_FILE_WAVE_INFO *info)
+mmf_file_wave_get_info(unsigned char *header, MM_FILE_WAVE_INFO *info)
{
if (!header || !info) {
return -1;
}
/*get chunk size*/
- info->size = *((int*)(header + 4));
-
+ info->size = *((int *)(header + 4));
+
/*get format*/
- info->format = *((short*)(header + 20));
+ info->format = *((short *)(header + 20));
/*get channel*/
- info->channel = *((short*)(header + 22));
+ info->channel = *((short *)(header + 22));
/*get sampling-rate*/
- info->sample_rate = *((int*)(header + 24));
+ info->sample_rate = *((int *)(header + 24));
/*get byte rate*/
- info->byte_rate = *((int*)(header + 28));
+ info->byte_rate = *((int *)(header + 28));
/*get byte align*/
- info->block_align = *((short*)(header + 32));
-
+ info->block_align = *((short *)(header + 32));
+
/*get bits per sample*/
- info->bits_per_sample = *((short*)(header + 34));
-
- info->size = mmfile_io_le_int32 (info->size);
- info->format = mmfile_io_le_int16 (info->format);
- info->channel = mmfile_io_le_int16 (info->channel);
- info->sample_rate = mmfile_io_le_int32 (info->sample_rate);
- info->byte_rate = mmfile_io_le_int32 (info->byte_rate);
- info->block_align = mmfile_io_le_int16 (info->block_align);
- info->bits_per_sample = mmfile_io_le_int16 (info->bits_per_sample);
-
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "----------------------------------------------\n");
- debug_msg ( "chunk size: %d\n", info->size);
- debug_msg ( "WAVE form Registration Number: 0x%04X\n", info->format);
- debug_msg ( "WAVE form wFormatTag ID: %s\n", _dump_codec_name (info->format));
- debug_msg ( "channel: %d\n", info->channel);
- debug_msg ( "sampling-rate: %d\n", info->sample_rate);
- debug_msg ( "byte-rate: %d\n", info->byte_rate);
- debug_msg ( "byte align: %d\n", info->block_align);
- debug_msg ( "bit per sample: %d\n", info->bits_per_sample);
- debug_msg ( "----------------------------------------------\n");
- #endif
+ info->bits_per_sample = *((short *)(header + 34));
+
+ info->size = mmfile_io_le_int32(info->size);
+ info->format = mmfile_io_le_int16(info->format);
+ info->channel = mmfile_io_le_int16(info->channel);
+ info->sample_rate = mmfile_io_le_int32(info->sample_rate);
+ info->byte_rate = mmfile_io_le_int32(info->byte_rate);
+ info->block_align = mmfile_io_le_int16(info->block_align);
+ info->bits_per_sample = mmfile_io_le_int16(info->bits_per_sample);
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------------------\n");
+ debug_msg("chunk size: %d\n", info->size);
+ debug_msg("WAVE form Registration Number: 0x%04X\n", info->format);
+ debug_msg("WAVE form wFormatTag ID: %s\n", _dump_codec_name(info->format));
+ debug_msg("channel: %d\n", info->channel);
+ debug_msg("sampling-rate: %d\n", info->sample_rate);
+ debug_msg("byte-rate: %d\n", info->byte_rate);
+ debug_msg("byte align: %d\n", info->block_align);
+ debug_msg("bit per sample: %d\n", info->bits_per_sample);
+ debug_msg("----------------------------------------------\n");
+#endif
return 0;
#define MMFILE_EXT_TP 0x7470
#define MMFILE_EXT_MPEG 0x6D706567
-int (*MMFileOpenFunc[MM_FILE_FORMAT_NUM+1]) (MMFileFormatContext *fileContext) = {
+int (*MMFileOpenFunc[MM_FILE_FORMAT_NUM + 1])(MMFileFormatContext *fileContext) = {
mmfile_format_open_ffmpg, /* 3GP */
mmfile_format_open_ffmpg, /* ASF */
mmfile_format_open_ffmpg, /* AVI */
NULL,
};
-static int _CleanupFrameContext (MMFileFormatContext *formatContext, bool clean_all)
+static int _CleanupFrameContext(MMFileFormatContext *formatContext, bool clean_all)
{
if (formatContext) {
if (formatContext->unsyncLyrics) mmfile_free(formatContext->unsyncLyrics);
if (formatContext->rotate) mmfile_free(formatContext->rotate);
- if(clean_all) //syncLyrics has to be freed in mm_file_destroy_tag_attrs() except abnormal status
+ if (clean_all) /*syncLyrics has to be freed in mm_file_destroy_tag_attrs() except abnormal status */
if (formatContext->syncLyrics) mm_file_free_synclyrics_list(formatContext->syncLyrics);
if (formatContext->privateFormatData) mmfile_free(formatContext->privateFormatData);
if (formatContext->thumbNail) {
if (formatContext->thumbNail->frameData)
- mmfile_free (formatContext->thumbNail->frameData);
+ mmfile_free(formatContext->thumbNail->frameData);
if (formatContext->thumbNail->configData)
- mmfile_free (formatContext->thumbNail->configData);
+ mmfile_free(formatContext->thumbNail->configData);
- mmfile_free (formatContext->thumbNail);
+ mmfile_free(formatContext->thumbNail);
}
formatContext->videoTotalTrackNum = 0;
}
static int
-_PreprocessFile (MMFileSourceType *fileSrc, char **urifilename, int *formatEnum, int *isdrm)
+_PreprocessFile(MMFileSourceType *fileSrc, char **urifilename, int *formatEnum, int *isdrm)
{
const char *fileName = NULL;
int filename_len = 0;
unsigned long long file_extansion = 0;
fileName = (const char *)(fileSrc->file.path);
- filename_len = strlen (fileName);
+ filename_len = strlen(fileName);
#ifdef DRM_SUPPORT
/**
drm_file_type_e file_type = DRM_TYPE_UNDEFINED;
int ret = 0;
- ret = drm_is_drm_file (fileSrc->file.path, &res);
- if (ret == DRM_RETURN_SUCCESS && DRM_TRUE == res)
- {
+ ret = drm_is_drm_file(fileSrc->file.path, &res);
+ if (ret == DRM_RETURN_SUCCESS && DRM_TRUE == res) {
ret = drm_get_file_type(fileSrc->file.path, &file_type);
- if((ret == DRM_RETURN_SUCCESS) && ((file_type == DRM_TYPE_OMA_V1) ||(file_type == DRM_TYPE_OMA_V2)))
- {
+ if ((ret == DRM_RETURN_SUCCESS) && ((file_type == DRM_TYPE_OMA_V1) || (file_type == DRM_TYPE_OMA_V2))) {
char extansion_name[_MMF_FILE_FILEEXT_MAX];
int i = 0;
*isdrm = MM_FILE_DRM_OMA;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("OMA DRM detected.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("OMA DRM detected.\n");
+#endif
memset(&contentInfo, 0x0, sizeof(drm_content_info_s));
- if (DRM_RETURN_SUCCESS != drm_get_content_info (fileSrc->file.path, &contentInfo)) {
- debug_error ("error: drm_get_content_info\n");
+ if (DRM_RETURN_SUCCESS != drm_get_content_info(fileSrc->file.path, &contentInfo)) {
+ debug_error("error: drm_get_content_info\n");
goto FILE_FORMAT_FAIL;
}
- memset (extansion_name, 0x00, _MMF_FILE_FILEEXT_MAX);
- if (MMFILE_UTIL_SUCCESS != mmfile_util_get_file_ext (contentInfo.mime_type, extansion_name)) {
- debug_error ("error: mmfile_util_get_ffmpeg_format\n");
+ memset(extansion_name, 0x00, _MMF_FILE_FILEEXT_MAX);
+ if (MMFILE_UTIL_SUCCESS != mmfile_util_get_file_ext(contentInfo.mime_type, extansion_name)) {
+ debug_error("error: mmfile_util_get_ffmpeg_format\n");
goto FILE_FORMAT_FAIL;
}
file_extansion = 0;
- for(i=0; i<stlen(extansion_name); i++) {
+ for (i = 0; i < stlen(extansion_name); i++) {
file_extansion |= (extansion_name[i] >= 'A' && extansion_name[i] <= 'Z' ? extansion_name[i] + 0x20 : extansion_name[i]) << i * 8;
}
- *urifilename = mmfile_malloc (MMFILE_DRM_URI_LEN + filename_len + 1);
+ *urifilename = mmfile_malloc(MMFILE_DRM_URI_LEN + filename_len + 1);
if (!*urifilename) {
- debug_error ("error: mmfile_malloc uriname\n");
+ debug_error("error: mmfile_malloc uriname\n");
goto FILE_FORMAT_FAIL;
}
- memset (*urifilename, 0x00, MMFILE_DRM_URI_LEN + filename_len + 1);
- strncpy (*urifilename, MMFILE_DRM_URI, MMFILE_DRM_URI_LEN);
- strncat (*urifilename, fileName, filename_len);
+ memset(*urifilename, 0x00, MMFILE_DRM_URI_LEN + filename_len + 1);
+ strncpy(*urifilename, MMFILE_DRM_URI, MMFILE_DRM_URI_LEN);
+ strncat(*urifilename, fileName, filename_len);
(*urifilename)[MMFILE_DRM_URI_LEN + filename_len] = '\0';
- }
- else if ((ret == DRM_RETURN_SUCCESS) &&
- ((file_type == DRM_TYPE_PLAYREADY) ||(file_type == DRM_TYPE_PLAYREADY_ENVELOPE) ||(file_type == DRM_TYPE_PIFF)))
- {
+ } else if ((ret == DRM_RETURN_SUCCESS) &&
+ ((file_type == DRM_TYPE_PLAYREADY) || (file_type == DRM_TYPE_PLAYREADY_ENVELOPE) || (file_type == DRM_TYPE_PIFF))) {
*isdrm = MM_FILE_DRM_PROTECTED;
}
- }
- else
-#endif // DRM_SUPPORT
+ } else
+#endif /* DRM_SUPPORT */
{
int pos = filename_len;
*isdrm = MM_FILE_DRM_NONE;
#ifdef __MMFILE_MMAP_MODE__
- *urifilename = mmfile_malloc (MMFILE_MMAP_URI_LEN + filename_len + 1);
+ *urifilename = mmfile_malloc(MMFILE_MMAP_URI_LEN + filename_len + 1);
if (!*urifilename) {
- debug_error ("error: mmfile_malloc uriname\n");
+ debug_error("error: mmfile_malloc uriname\n");
goto FILE_FORMAT_FAIL;
}
- memset (*urifilename, 0x00, MMFILE_MMAP_URI_LEN + filename_len + 1);
- strncpy (*urifilename, MMFILE_MMAP_URI, MMFILE_MMAP_URI_LEN);
- strncat (*urifilename, fileName, filename_len);
+ memset(*urifilename, 0x00, MMFILE_MMAP_URI_LEN + filename_len + 1);
+ strncpy(*urifilename, MMFILE_MMAP_URI, MMFILE_MMAP_URI_LEN);
+ strncat(*urifilename, fileName, filename_len);
(*urifilename)[MMFILE_MMAP_URI_LEN + filename_len] = '\0';
#else
- *urifilename = mmfile_malloc (MMFILE_FILE_URI_LEN + filename_len + 1);
+ *urifilename = mmfile_malloc(MMFILE_FILE_URI_LEN + filename_len + 1);
if (!*urifilename) {
- debug_error ("error: mmfile_malloc uriname\n");
+ debug_error("error: mmfile_malloc uriname\n");
goto FILE_FORMAT_FAIL;
}
- memset (*urifilename, 0x00, MMFILE_FILE_URI_LEN + filename_len + 1);
- strncpy (*urifilename, MMFILE_FILE_URI, MMFILE_FILE_URI_LEN+1);
- strncat (*urifilename, fileName, filename_len);
+ memset(*urifilename, 0x00, MMFILE_FILE_URI_LEN + filename_len + 1);
+ strncpy(*urifilename, MMFILE_FILE_URI, MMFILE_FILE_URI_LEN + 1);
+ strncat(*urifilename, fileName, filename_len);
(*urifilename)[MMFILE_FILE_URI_LEN + filename_len] = '\0';
#endif
/**
}
}
- ret = mmfile_open (&fp, *urifilename, MMFILE_RDONLY);
+ ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto FILE_FORMAT_FAIL;
}
- ///////////////////////////////////////////////////////////////////////
- // Check File format //
- ///////////////////////////////////////////////////////////////////////
+ /*///////////////////////////////////////////////////////////////////// */
+ /* Check File format // */
+ /*///////////////////////////////////////////////////////////////////// */
- #ifdef __MMFILE_TEST_MODE__
- //debug_msg ("Get codec type of [%s].\n", extansion_name);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ /*debug_msg ("Get codec type of [%s].\n", extansion_name); */
+#endif
- switch(file_extansion) {
+ switch (file_extansion) {
case MMFILE_EXT_MP4:
case MMFILE_EXT_MPEG4:
case MMFILE_EXT_M4A:
case MMFILE_EXT_MPG:
case MMFILE_EXT_MPG4:
case MMFILE_EXT_M4V:
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MP4;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_3GP:
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_3GP;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_AMR:
case MMFILE_EXT_AWB:
- if (MMFileFormatIsValidAMR (fp, NULL)) {
+ if (MMFileFormatIsValidAMR(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AMR;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_WAV:
- if (MMFileFormatIsValidWAV (fp, NULL)) {
+ if (MMFileFormatIsValidWAV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WAV;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_MID:
case MMFILE_EXT_MIDI:
case MMFILE_EXT_SPM:
- if (MMFileFormatIsValidMID (fp, NULL)) {
+ if (MMFileFormatIsValidMID(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MID;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_MP3:
- if (MMFileFormatIsValidMP3 (fp, NULL, 5)) {
+ if (MMFileFormatIsValidMP3(fp, NULL, 5)) {
*formatEnum = MM_FILE_FORMAT_MP3;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_AAC:
- if (MMFileFormatIsValidAAC (fp, NULL)) {
+ if (MMFileFormatIsValidAAC(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AAC;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_XMF:
case MMFILE_EXT_MXMF:
- if (MMFileFormatIsValidMID (fp, NULL)) {
+ if (MMFileFormatIsValidMID(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MID;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_MMF:
case MMFILE_EXT_MA2:
- if (MMFileFormatIsValidMMF (fp, NULL)) {
+ if (MMFileFormatIsValidMMF(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MMF;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_IMY:
- if (MMFileFormatIsValidIMY (fp, NULL)) {
+ if (MMFileFormatIsValidIMY(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_IMELODY;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_AVI:
- if (MMFileFormatIsValidAVI (fp, NULL)) {
+ if (MMFileFormatIsValidAVI(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AVI;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_DIVX:
- if (MMFileFormatIsValidAVI (fp, NULL)) {
+ if (MMFileFormatIsValidAVI(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_DIVX;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_ASF:
case MMFILE_EXT_ASX:
- if (MMFileFormatIsValidASF (fp, NULL)) {
+ if (MMFileFormatIsValidASF(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_ASF;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_WMA:
- if (MMFileFormatIsValidWMA (fp, NULL)) {
+ if (MMFileFormatIsValidWMA(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WMA;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_WMV:
- if (MMFileFormatIsValidWMV (fp, NULL)) {
+ if (MMFileFormatIsValidWMV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WMV;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_OGG:
- if (MMFileFormatIsValidOGG (fp, NULL)) {
+ if (MMFileFormatIsValidOGG(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_OGG;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_MKV:
case MMFILE_EXT_MKA:
- if (MMFileFormatIsValidMatroska (fp, NULL)) {
+ if (MMFileFormatIsValidMatroska(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MATROSKA;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_MOV:
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_QT;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_FLAC:
- if (MMFileFormatIsValidFLAC (fp, NULL)) {
+ if (MMFileFormatIsValidFLAC(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_FLAC;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_FLV:
- if (MMFileFormatIsValidFLV (fp, NULL)) {
+ if (MMFileFormatIsValidFLV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_FLV;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_RM:
case MMFILE_EXT_RMVB:
- if (MMFileFormatIsValidREAL (fp, NULL)) {
+ if (MMFileFormatIsValidREAL(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_REAL;
goto FILE_FORMAT_SUCCESS;
}
case MMFILE_EXT_MTS:
case MMFILE_EXT_TP:
case MMFILE_EXT_TS:
- if (MMFileFormatIsValidMPEGTS (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M2TS;
goto FILE_FORMAT_SUCCESS;
}
break;
case MMFILE_EXT_MPEG:
- if (MMFileFormatIsValidMPEGPS (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M2PS;
goto FILE_FORMAT_SUCCESS;
- } else if (MMFileFormatIsValidMPEGVIDEO (fp, NULL)) {
+ } else if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M1VIDEO;
goto FILE_FORMAT_SUCCESS;
}
goto FILE_FORMAT_SUCCESS;
break;
- default :
- debug_warning ("probe file type=%s\n", fileName);
+ default:
+ debug_warning("probe file type=%s\n", fileName);
skip_index = -1;
goto PROBE_PROPER_FILE_TYPE;
break;
}
} else if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) {
- char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0,};
+ char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0, };
- sprintf (tempURIBuffer, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)fileSrc->memory.ptr, fileSrc->memory.size);
- *urifilename = mmfile_strdup (tempURIBuffer);
+ sprintf(tempURIBuffer, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)fileSrc->memory.ptr, fileSrc->memory.size);
+ *urifilename = mmfile_strdup(tempURIBuffer);
if (!*urifilename) {
- debug_error ("error: uri is NULL\n");
+ debug_error("error: uri is NULL\n");
goto FILE_FORMAT_FAIL;
}
- ret = mmfile_open (&fp, *urifilename, MMFILE_RDONLY);
+ ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto FILE_FORMAT_FAIL;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("uri: %s\n", *urifilename);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("uri: %s\n", *urifilename);
+#endif
switch (fileSrc->memory.format) {
case MM_FILE_FORMAT_3GP: {
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_3GP;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_MP4: {
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MP4;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_AMR: {
- if (MMFileFormatIsValidAMR (fp, NULL)) {
+ if (MMFileFormatIsValidAMR(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AMR;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_WAV: {
- if (MMFileFormatIsValidWAV (fp, NULL)) {
+ if (MMFileFormatIsValidWAV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WAV;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_MID: {
- if (MMFileFormatIsValidMID (fp, NULL)) {
+ if (MMFileFormatIsValidMID(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MID;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_MP3: {
- if (MMFileFormatIsValidMP3 (fp, NULL, 5)) {
+ if (MMFileFormatIsValidMP3(fp, NULL, 5)) {
*formatEnum = MM_FILE_FORMAT_MP3;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_AAC: {
- if (MMFileFormatIsValidAAC (fp, NULL)) {
+ if (MMFileFormatIsValidAAC(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AAC;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_MMF: {
- if (MMFileFormatIsValidMMF (fp, NULL)) {
+ if (MMFileFormatIsValidMMF(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MMF;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_IMELODY: {
- if (MMFileFormatIsValidIMY (fp, NULL)) {
+ if (MMFileFormatIsValidIMY(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_IMELODY;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_AVI: {
- if (MMFileFormatIsValidAVI (fp, NULL)) {
+ if (MMFileFormatIsValidAVI(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AVI;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_DIVX: {
- if (MMFileFormatIsValidAVI (fp, NULL)) {
+ if (MMFileFormatIsValidAVI(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_DIVX;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_ASF: {
- if (MMFileFormatIsValidASF (fp, NULL)) {
+ if (MMFileFormatIsValidASF(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_ASF;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_WMA: {
- if (MMFileFormatIsValidWMA (fp, NULL)) {
+ if (MMFileFormatIsValidWMA(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WMA;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_WMV: {
- if (MMFileFormatIsValidWMV (fp, NULL)) {
+ if (MMFileFormatIsValidWMV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WMV;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_OGG: {
- if (MMFileFormatIsValidOGG (fp, NULL)) {
+ if (MMFileFormatIsValidOGG(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_OGG;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_MATROSKA: {
- if (MMFileFormatIsValidMatroska (fp, NULL)) {
+ if (MMFileFormatIsValidMatroska(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MATROSKA;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_QT: {
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_QT;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_FLAC: {
- if (MMFileFormatIsValidFLAC (fp, NULL)) {
+ if (MMFileFormatIsValidFLAC(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_FLAC;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_FLV: {
- if (MMFileFormatIsValidFLV (fp, NULL)) {
+ if (MMFileFormatIsValidFLV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_FLV;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_REAL: {
- if (MMFileFormatIsValidREAL (fp, NULL)) {
+ if (MMFileFormatIsValidREAL(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_REAL;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_M2TS: {
- if (MMFileFormatIsValidMPEGTS (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M2TS;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_M2PS: {
- if (MMFileFormatIsValidMPEGPS (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M2PS;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_M1AUDIO: {
- if (MMFileFormatIsValidMPEGAUDIO (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGAUDIO(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M1AUDIO;
goto FILE_FORMAT_SUCCESS;
}
}
case MM_FILE_FORMAT_M1VIDEO: {
- if (MMFileFormatIsValidMPEGVIDEO (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M1VIDEO;
goto FILE_FORMAT_SUCCESS;
}
}
default: {
- debug_warning ("probe fileformat type=%d (%d: autoscan)\n", fileSrc->memory.format, MM_FILE_FORMAT_INVALID);
+ debug_warning("probe fileformat type=%d (%d: autoscan)\n", fileSrc->memory.format, MM_FILE_FORMAT_INVALID);
skip_index = -1;
goto PROBE_PROPER_FILE_TYPE;
break;
}
}
} else {
- debug_error ("error: invaild input type[memory|file]\n");
+ debug_error("error: invaild input type[memory|file]\n");
goto FILE_FORMAT_FAIL;
}
if (index == skip_index)
continue;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("search index = [%d]\n", index);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("search index = [%d]\n", index);
+#endif
switch (index) {
case MM_FILE_FORMAT_QT:
if (skip_index == MM_FILE_FORMAT_QT || skip_index == MM_FILE_FORMAT_3GP || skip_index == MM_FILE_FORMAT_MP4)
goto FILE_FORMAT_FAIL;
- if (MMFileFormatIsValidMP4 (fp, NULL)) {
+ if (MMFileFormatIsValidMP4(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_3GP;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_3GP;
goto FILE_FORMAT_SUCCESS;
if (skip_index == MM_FILE_FORMAT_ASF || skip_index == MM_FILE_FORMAT_WMA || skip_index == MM_FILE_FORMAT_WMV)
goto FILE_FORMAT_FAIL;
- if (MMFileFormatIsValidASF (fp, NULL)) {
+ if (MMFileFormatIsValidASF(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_ASF;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_ASF;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_OGG: {
- if (MMFileFormatIsValidOGG (fp, NULL)) {
+ if (MMFileFormatIsValidOGG(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_OGG;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_OGG;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_AMR: {
- if (MMFileFormatIsValidAMR (fp, NULL)) {
+ if (MMFileFormatIsValidAMR(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AMR;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_AMR;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_AAC: {
- if (MMFileFormatIsValidAAC (fp, NULL)) {
+ if (MMFileFormatIsValidAAC(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_AAC;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_AAC;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_MP3: {
- if (MMFileFormatIsValidMP3 (fp, NULL, 50)) {
+ if (MMFileFormatIsValidMP3(fp, NULL, 50)) {
*formatEnum = MM_FILE_FORMAT_MP3;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MP3;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_WAV: {
- if (MMFileFormatIsValidWAV (fp, NULL)) {
+ if (MMFileFormatIsValidWAV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_WAV;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_WAV;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_MID: {
- if (MMFileFormatIsValidMID (fp, NULL)) {
+ if (MMFileFormatIsValidMID(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MID;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MID;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_MMF: {
- if (MMFileFormatIsValidMMF (fp, NULL)) {
+ if (MMFileFormatIsValidMMF(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MMF;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MMF;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_IMELODY: {
- if (MMFileFormatIsValidIMY (fp, NULL)) {
+ if (MMFileFormatIsValidIMY(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_IMELODY;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_IMELODY;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_MATROSKA: {
- if (MMFileFormatIsValidMatroska (fp, NULL)) {
+ if (MMFileFormatIsValidMatroska(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_MATROSKA;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MATROSKA;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_FLAC: {
- if (MMFileFormatIsValidFLAC (fp, NULL)) {
+ if (MMFileFormatIsValidFLAC(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_FLAC;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_FLAC;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_FLV: {
- if (MMFileFormatIsValidFLV (fp, NULL)) {
+ if (MMFileFormatIsValidFLV(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_FLV;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_FLV;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_REAL: {
- if (MMFileFormatIsValidREAL (fp, NULL)) {
+ if (MMFileFormatIsValidREAL(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_REAL;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_REAL;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_M2TS: {
- if (MMFileFormatIsValidMPEGTS (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M2TS;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M2TS;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_M2PS: {
- if (MMFileFormatIsValidMPEGPS (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M2PS;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M2PS;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_M1AUDIO: {
- if (MMFileFormatIsValidMPEGAUDIO (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGAUDIO(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M1AUDIO;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M1AUDIO;
goto FILE_FORMAT_SUCCESS;
}
case MM_FILE_FORMAT_M1VIDEO: {
- if (MMFileFormatIsValidMPEGVIDEO (fp, NULL)) {
+ if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
*formatEnum = MM_FILE_FORMAT_M1VIDEO;
if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M1VIDEO;
goto FILE_FORMAT_SUCCESS;
case MM_FILE_FORMAT_VOB:
case MM_FILE_FORMAT_JPG:
default: {
- debug_error ("error: invaild format enum[%d]\n", index);
+ debug_error("error: invaild format enum[%d]\n", index);
goto FILE_FORMAT_FAIL;
break;
}
*formatEnum = -1;
- if(fp)
+ if (fp)
mmfile_close(fp);
return MMFILE_FORMAT_FAIL;
FILE_FORMAT_SUCCESS:
- if(fp)
+ if (fp)
mmfile_close(fp);
return MMFILE_FORMAT_SUCCESS;
}
-static int _mmfile_format_close (MMFileFormatContext *formatContext, bool clean_all)
+static int _mmfile_format_close(MMFileFormatContext *formatContext, bool clean_all)
{
if (NULL == formatContext) {
- debug_error ("error: invalid params\n");
+ debug_error("error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
_CleanupFrameContext(formatContext, clean_all);
if (formatContext)
- mmfile_free (formatContext);
+ mmfile_free(formatContext);
return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
-int mmfile_format_open (MMFileFormatContext **formatContext, MMFileSourceType *fileSrc)
+int mmfile_format_open(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc)
{
int index = 0;
int ret = 0;
MMFileFormatContext *formatObject = NULL;
if (NULL == fileSrc) {
- debug_error ("error: invalid params\n");
+ debug_error("error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
/* create formatContext object */
- formatObject = mmfile_malloc (sizeof (MMFileFormatContext));
+ formatObject = mmfile_malloc(sizeof(MMFileFormatContext));
if (NULL == formatObject) {
- debug_error ("error: mmfile_malloc fail for formatObject\n");
+ debug_error("error: mmfile_malloc fail for formatObject\n");
*formatContext = NULL;
return MMFILE_FORMAT_FAIL;
}
- memset (formatObject, 0x00, sizeof (MMFileFormatContext));
+ memset(formatObject, 0x00, sizeof(MMFileFormatContext));
mmfile_register_io_all();
/**
* Format detect and validation check.
*/
- ret = _PreprocessFile (fileSrc, &formatObject->uriFileName, &formatObject->formatType, &formatObject->isdrm);
+ ret = _PreprocessFile(fileSrc, &formatObject->uriFileName, &formatObject->formatType, &formatObject->isdrm);
if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error ("error: _PreprocessFile fail\n");
+ debug_error("error: _PreprocessFile fail\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
* Open format function.
*/
if (NULL == MMFileOpenFunc[formatObject->formatType]) {
- debug_error ("error: Not implemented \n");
+ debug_error("error: Not implemented \n");
ret = MMFILE_FORMAT_FAIL;
goto find_valid_handler;
}
- ret = MMFileOpenFunc[formatObject->formatType] (formatObject);
+ ret = MMFileOpenFunc[formatObject->formatType](formatObject);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error ("error: Try other formats\n");
+ debug_error("error: Try other formats\n");
ret = MMFILE_FORMAT_FAIL;
-// goto find_valid_handler;
+/* goto find_valid_handler; */
goto exception;
}
find_valid_handler:
formatObject->pre_checked = 0; /*do check file format*/
- for (index = 0; index < MM_FILE_FORMAT_NUM+1; index++) {
+ for (index = 0; index < MM_FILE_FORMAT_NUM + 1; index++) {
if (NULL == MMFileOpenFunc[index]) {
- debug_error ("error: Not implemented \n");
+ debug_error("error: Not implemented \n");
ret = MMFILE_FORMAT_FAIL;
continue;
}
if (formatObject->formatType == index)
continue;
- ret = MMFileOpenFunc[index] (formatObject);
+ ret = MMFileOpenFunc[index](formatObject);
if (MMFILE_FORMAT_FAIL == ret) {
-// _CleanupFrameContext (formatObject, true);
+/* _CleanupFrameContext(formatObject, true); */
continue;
}
formatObject->formatType = index;
if (index == MM_FILE_FORMAT_NUM + 1 && MMFILE_FORMAT_FAIL == ret) {
- debug_error ("can't find file format handler\n");
- _CleanupFrameContext (formatObject, true);
+ debug_error("can't find file format handler\n");
+ _CleanupFrameContext(formatObject, true);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
return MMFILE_FORMAT_SUCCESS;
exception:
- _mmfile_format_close (formatObject, true);
+ _mmfile_format_close(formatObject, true);
*formatContext = NULL;
return ret;
}
EXPORT_API
-int mmfile_format_read_stream (MMFileFormatContext *formatContext)
+int mmfile_format_read_stream(MMFileFormatContext *formatContext)
{
if (NULL == formatContext || NULL == formatContext->ReadStream) {
- debug_error ("error: invalid params\n");
+ debug_error("error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
- return formatContext->ReadStream (formatContext);
+ return formatContext->ReadStream(formatContext);
}
EXPORT_API
-int mmfile_format_read_frame (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
+int mmfile_format_read_frame(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
- if (NULL == formatContext || NULL == frame || NULL == formatContext->ReadFrame ) {
- debug_error ("error: invalid params\n");
+ if (NULL == formatContext || NULL == frame || NULL == formatContext->ReadFrame) {
+ debug_error("error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
- return formatContext->ReadFrame (formatContext, timestamp, frame);
+ return formatContext->ReadFrame(formatContext, timestamp, frame);
}
EXPORT_API
-int mmfile_format_read_tag (MMFileFormatContext *formatContext)
+int mmfile_format_read_tag(MMFileFormatContext *formatContext)
{
if (NULL == formatContext || NULL == formatContext->ReadTag) {
- debug_error ("error: invalid params\n");
+ debug_error("error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
- return formatContext->ReadTag (formatContext);
+ return formatContext->ReadTag(formatContext);
}
EXPORT_API
-int mmfile_format_close (MMFileFormatContext *formatContext)
+int mmfile_format_close(MMFileFormatContext *formatContext)
{
return _mmfile_format_close(formatContext, false);
}
mm_file_create_tag_attrs(&tag_attrs, filename);
// get attributes of tag
-ret = mm_file_get_attrs( tag_attrs,
+ret = mm_file_get_attrs(tag_attrs,
&err_attr_name,
MM_FILE_TAG_ARTIST, &ctag.artist.value.s_val, &ctag.artist.len,
MM_FILE_TAG_ALBUM, &ctag.album.value.s_val, &ctag.album.len,
* @endcode
*/
-int mm_file_create_tag_attrs(MMHandleType * tag_attrs, const char * filename);
+int mm_file_create_tag_attrs(MMHandleType *tag_attrs, const char *filename);
/**
* This function is to destory the tag attribute handle which is created by mm_file_create_tag_attrs().<BR>
mm_file_create_tag_attrs(&tag_attrs, filename);
// get attributes of tag
-ret = mm_file_get_attrs( tag_attrs,
+ret = mm_file_get_attrs(tag_attrs,
&err_attr_name,
MM_FILE_TAG_ARTIST, &ctag.artist.value.s_val, &ctag.artist.len,
MM_FILE_TAG_ALBUM, &ctag.album.value.s_val, &ctag.album.len,
*/
int mm_file_destroy_tag_attrs(MMHandleType tag_attrs);
- /**
- * This function is to create content attribute from media file.<BR>
- * Handle can be used to get actual content information by mm_file_get_attrs() after this function.<BR>
- * Handle should be destroyed using mm_file_destroy_content_attrs() after use.<BR>
- *
- * @param content_attrs [out] content attribute handle.
- * @param filename [in] file path.
- *
- * @return This function returns MM_ERROR_NONE on success, or negative value with error code.
- *
- * @remark Filename must be UTF-8 format.
- *
- * @pre File should be exists.
- * @post Handle is ready to use.
- * @see mm_file_destroy_content_attrs, mm_file_get_attrs
- * @par Example:
- * @code
+/**
+ * This function is to create content attribute from media file.<BR>
+ * Handle can be used to get actual content information by mm_file_get_attrs() after this function.<BR>
+ * Handle should be destroyed using mm_file_destroy_content_attrs() after use.<BR>
+ *
+ * @param content_attrs [out] content attribute handle.
+ * @param filename [in] file path.
+ *
+ * @return This function returns MM_ERROR_NONE on success, or negative value with error code.
+ *
+ * @remark Filename must be UTF-8 format.
+ *
+ * @pre File should be exists.
+ * @post Handle is ready to use.
+ * @see mm_file_destroy_content_attrs, mm_file_get_attrs
+ * @par Example:
+ * @code
#include <mm_file.h>
// get track info
// Destory content handle
mm_file_destroy_content_attrs(content_attrs);
- * @endcode
- */
+ * @endcode
+ */
int mm_file_create_content_attrs(MMHandleType *content_attrs, const char *filename);
/**
#include <mm_file.h>
// create tag handle from memory
-mm_file_create_tag_attrs_from_memory (&tag_attrs, data, size, MM_FILE_FORMAT_MP3);
+mm_file_create_tag_attrs_from_memory(&tag_attrs, data, size, MM_FILE_FORMAT_MP3);
// get audio artist & album tag
mm_file_get_attrs(tag_attrs,
#include <mm_file.h>
// create content handle from memory
-mm_file_create_content_attrs_from_memory (&content_attrs, data, size, MM_FILE_FORMAT_MP3);
+mm_file_create_content_attrs_from_memory(&content_attrs, data, size, MM_FILE_FORMAT_MP3);
// get audio bit rate and sample rate
mm_file_get_attrs(content_attrs,
* @endcode
*/
-int mm_file_get_stream_info(const char* filename, int *audio_stream_num, int *video_stream_num);
-
- /**
- * This function is to get the content attributes without thumbnail from media file.<BR>
- * This function is almost same as mm_file_create_content_attrs() except extracting thumbnail feature.<BR>
- * As this function is not extracting thumbnail, this is faster than mm_file_create_content_attrs().
- *
- * @param content_attrs [out] content attribute handle.
- * @param filename [in] file path.
- *
- * @return This function returns MM_ERROR_NONE on success, or negative value with error code.
- *
- * @remark Filename must be UTF-8 format.
- *
- * @pre File should be exists.
- * @post Handle is ready to use.
- * @see mm_file_destroy_content_attrs, mm_file_get_attrs
- * @par Example::
- * @code
+int mm_file_get_stream_info(const char *filename, int *audio_stream_num, int *video_stream_num);
+
+/**
+ * This function is to get the content attributes without thumbnail from media file.<BR>
+ * This function is almost same as mm_file_create_content_attrs() except extracting thumbnail feature.<BR>
+ * As this function is not extracting thumbnail, this is faster than mm_file_create_content_attrs().
+ *
+ * @param content_attrs [out] content attribute handle.
+ * @param filename [in] file path.
+ *
+ * @return This function returns MM_ERROR_NONE on success, or negative value with error code.
+ *
+ * @remark Filename must be UTF-8 format.
+ *
+ * @pre File should be exists.
+ * @post Handle is ready to use.
+ * @see mm_file_destroy_content_attrs, mm_file_get_attrs
+ * @par Example::
+ * @code
#include <mm_file.h>
// create content handle
mm_file_create_content_attrs_simple(&content_attrs, filename);
-// get width,height information
+// get width, height information
mm_file_get_attrs(content_attrs,
NULL,
MM_FILE_CONTENT_VIDEO_WIDTH, &ccontent.video_w,
// Destory content handle
mm_file_destroy_content_attrs(content_attrs);
- * @endcode
- */
+ * @endcode
+ */
int mm_file_create_content_attrs_simple(MMHandleType *content_attrs, const char *filename);
int mm_file_create_content_attrs_safe(MMHandleType *content_attrs, const char *filename);
* @see metadata_extractor_create(), metadata_extractor_destroy()
*/
-int mm_file_get_video_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+int mm_file_get_video_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
int mm_file_get_video_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
-int mm_file_check_uhqa(const char* filename, bool *is_uhqa);
+int mm_file_check_uhqa(const char *filename, bool *is_uhqa);
/**
@}
#define MMFILE_AUDIO_DECODE 1
-typedef struct _mmfileframe
-{
- unsigned int width;
- unsigned int height;
- unsigned int version;
- unsigned int configLen;
- unsigned int frameDataSize;
- unsigned char *frameData;
- void *configData;
+typedef struct _mmfileframe {
+ unsigned int width;
+ unsigned int height;
+ unsigned int version;
+ unsigned int configLen;
+ unsigned int frameDataSize;
+ unsigned char *frameData;
+ void *configData;
} MMFileCodecFrame;
typedef struct _mmfilecodecctx MMFileCodecContext;
-struct _mmfilecodecctx
-{
- /* MMFILE_AUDIO_DECODE or MMFILE_VIDEO_DECODE */
- int codecType;
- int codecId;
- int version;
+struct _mmfilecodecctx {
+ /* MMFILE_AUDIO_DECODE or MMFILE_VIDEO_DECODE */
+ int codecType;
+ int codecId;
+ int version;
- /* private data */
- void *privateData;
+ /* private data */
+ void *privateData;
- /* resource free */
- int (*Decode) (MMFileCodecContext*,MMFileCodecFrame*);
- int (*Close) (MMFileCodecContext*);
+ /* resource free */
+ int (*Decode)(MMFileCodecContext *, MMFileCodecFrame *);
+ int (*Close)(MMFileCodecContext *);
};
#ifndef __MMFILE_DYN_LOADING__
-int mmfile_codec_open (MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
-int mmfile_codec_decode (MMFileCodecContext *codecContext, MMFileCodecFrame *output);
-int mmfile_codec_close (MMFileCodecContext *codecContext);
-#endif
+int mmfile_codec_open(MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
+int mmfile_codec_decode(MMFileCodecContext *codecContext, MMFileCodecFrame *output);
+int mmfile_codec_close(MMFileCodecContext *codecContext);
+#endif
#ifdef __cplusplus
}
*/
#ifndef __MMFILE_DYN_LOADING__
-int mmfile_format_get_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+int mmfile_format_get_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
int mmfile_format_get_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
#endif
#define MMFILE_FORMAT_FAIL 0
-#define MM_FILE_SET_MEDIA_FILE_SRC(Media,Filename) do { \
- (Media).type = MM_FILE_SRC_TYPE_FILE; \
- (Media).file.path = ((strstr(Filename,"file://")!=NULL)? Filename+7:Filename); \
-} while (0);
+#define MM_FILE_SET_MEDIA_FILE_SRC(Media, Filename) do { \
+ (Media).type = MM_FILE_SRC_TYPE_FILE; \
+ (Media).file.path = ((strstr(Filename, "file://")!=NULL) ? Filename+7:Filename); \
+ } while (0);
-#define MM_FILE_SET_MEDIA_MEM_SRC(Media,Memory,Size,Format) do { \
- (Media).type = MM_FILE_SRC_TYPE_MEMORY; \
- (Media).memory.ptr = (Memory); \
- (Media).memory.size = (Size); \
- (Media).memory.format = (Format); \
-} while (0);
+#define MM_FILE_SET_MEDIA_MEM_SRC(Media, Memory, Size, Format) do { \
+ (Media).type = MM_FILE_SRC_TYPE_MEMORY; \
+ (Media).memory.ptr = (Memory); \
+ (Media).memory.size = (Size); \
+ (Media).memory.format = (Format); \
+ } while (0);
void *privateCodecData;
/* function pointer */
- int (*ReadStream) (MMFileFormatContext*);
- int (*ReadFrame) (MMFileFormatContext*,unsigned int,MMFileFormatFrame*);
- int (*ReadTag) (MMFileFormatContext*);
- int (*Close) (MMFileFormatContext*);
+ int (*ReadStream)(MMFileFormatContext *);
+ int (*ReadFrame)(MMFileFormatContext *, unsigned int, MMFileFormatFrame *);
+ int (*ReadTag)(MMFileFormatContext *);
+ int (*Close)(MMFileFormatContext *);
};
#ifndef __MMFILE_DYN_LOADING__
-int mmfile_format_open (MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
-int mmfile_format_read_stream (MMFileFormatContext *formatContext);
-int mmfile_format_read_frame (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int mmfile_format_read_tag (MMFileFormatContext *formatContext);
-int mmfile_format_close (MMFileFormatContext *formatContext);
+int mmfile_format_open(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
+int mmfile_format_read_stream(MMFileFormatContext *formatContext);
+int mmfile_format_read_frame(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int mmfile_format_read_tag(MMFileFormatContext *formatContext);
+int mmfile_format_close(MMFileFormatContext *formatContext);
#endif
#ifdef __cplusplus
#include <sys/time.h>
-//#define CHECK_TIME
+/*#define CHECK_TIME */
#ifdef CHECK_TIME
int64_t gettime(void)
{
struct timeval tv;
- gettimeofday(&tv,NULL);
+ gettimeofday(&tv, NULL);
return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
}
#endif
#define MMFILE_FORMAT_SO_FILE_NAME "libmmfile_formats.so"
#define MMFILE_CODEC_SO_FILE_NAME "libmmfile_codecs.so"
-int (*mmfile_format_open) (MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
-int (*mmfile_format_read_stream) (MMFileFormatContext *formatContext);
-int (*mmfile_format_read_frame) (MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
-int (*mmfile_format_read_tag) (MMFileFormatContext *formatContext);
-int (*mmfile_format_close) (MMFileFormatContext *formatContext);
-int (*mmfile_codec_open) (MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
-int (*mmfile_codec_decode) (MMFileCodecContext *codecContext, MMFileCodecFrame *output);
-int (*mmfile_codec_close) (MMFileCodecContext *codecContext);
-int (*mmfile_format_get_frame) (const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
-int (*mmfile_format_get_frame_from_memory) (const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+int (*mmfile_format_open)(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
+int (*mmfile_format_read_stream)(MMFileFormatContext *formatContext);
+int (*mmfile_format_read_frame)(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
+int (*mmfile_format_read_tag)(MMFileFormatContext *formatContext);
+int (*mmfile_format_close)(MMFileFormatContext *formatContext);
+int (*mmfile_codec_open)(MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
+int (*mmfile_codec_decode)(MMFileCodecContext *codecContext, MMFileCodecFrame *output);
+int (*mmfile_codec_close)(MMFileCodecContext *codecContext);
+int (*mmfile_format_get_frame)(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+int (*mmfile_format_get_frame_from_memory)(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
#endif
#ifdef __MMFILE_DYN_LOADING__
-static int _load_dynamic_functions (MMFILE_FUNC_HANDLE* pHandle)
+static int _load_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
{
-// static int dll_func_initialized = 0; //disabled
+/* static int dll_func_initialized = 0; //disabled */
int ret = 0;
/* Get from function argument */
void *formatFuncHandle = NULL;
- void *codecFuncHandle = NULL;
+ void *codecFuncHandle = NULL;
/* disabled
if (dll_func_initialized) {
}
*/
- formatFuncHandle = dlopen (MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
+ formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
if (!formatFuncHandle) {
- debug_error ("error: %s\n", dlerror());
+ debug_error("error: %s\n", dlerror());
ret = 0;
goto exception;
}
- mmfile_format_open = dlsym (formatFuncHandle, "mmfile_format_open");
- mmfile_format_read_stream = dlsym (formatFuncHandle, "mmfile_format_read_stream");
- mmfile_format_read_frame = dlsym (formatFuncHandle, "mmfile_format_read_frame");
- mmfile_format_read_tag = dlsym (formatFuncHandle, "mmfile_format_read_tag");
- mmfile_format_close = dlsym (formatFuncHandle, "mmfile_format_close");
+ mmfile_format_open = dlsym(formatFuncHandle, "mmfile_format_open");
+ mmfile_format_read_stream = dlsym(formatFuncHandle, "mmfile_format_read_stream");
+ mmfile_format_read_frame = dlsym(formatFuncHandle, "mmfile_format_read_frame");
+ mmfile_format_read_tag = dlsym(formatFuncHandle, "mmfile_format_read_tag");
+ mmfile_format_close = dlsym(formatFuncHandle, "mmfile_format_close");
- if ( !mmfile_format_open ||
- !mmfile_format_read_stream ||
- !mmfile_format_read_frame ||
- !mmfile_format_read_tag ||
- !mmfile_format_close) {
+ if (!mmfile_format_open ||
+ !mmfile_format_read_stream ||
+ !mmfile_format_read_frame ||
+ !mmfile_format_read_tag ||
+ !mmfile_format_close) {
- debug_error ("error: %s\n", dlerror());
+ debug_error("error: %s\n", dlerror());
ret = 0;
goto exception;
}
/*closed at app termination.*/
- //dlclose (formatFuncHandle);
+ /*dlclose (formatFuncHandle); */
- codecFuncHandle = dlopen (MMFILE_CODEC_SO_FILE_NAME, RTLD_LAZY | RTLD_GLOBAL);
+ codecFuncHandle = dlopen(MMFILE_CODEC_SO_FILE_NAME, RTLD_LAZY | RTLD_GLOBAL);
if (!codecFuncHandle) {
- debug_error ("error: %s\n", dlerror());
+ debug_error("error: %s\n", dlerror());
ret = 0;
goto exception;
}
- mmfile_codec_open = dlsym (codecFuncHandle, "mmfile_codec_open");
- mmfile_codec_decode = dlsym (codecFuncHandle, "mmfile_codec_decode");
- mmfile_codec_close = dlsym (codecFuncHandle, "mmfile_codec_close");
+ mmfile_codec_open = dlsym(codecFuncHandle, "mmfile_codec_open");
+ mmfile_codec_decode = dlsym(codecFuncHandle, "mmfile_codec_decode");
+ mmfile_codec_close = dlsym(codecFuncHandle, "mmfile_codec_close");
- if ( !mmfile_codec_open || !mmfile_codec_decode || !mmfile_codec_close) {
- debug_error ("error: %s\n", dlerror());
+ if (!mmfile_codec_open || !mmfile_codec_decode || !mmfile_codec_close) {
+ debug_error("error: %s\n", dlerror());
ret = 0;
goto exception;
}
/*closed at app termination.*/
- //dlclose (codecFuncHandle);
+ /*dlclose (codecFuncHandle); */
-// dll_func_initialized = 1; // disabled
+/* dll_func_initialized = 1; // disabled */
pHandle->codecFuncHandle = codecFuncHandle;
pHandle->formatFuncHandle = formatFuncHandle;
return 1;
exception:
- if (formatFuncHandle) dlclose (formatFuncHandle);
- if (codecFuncHandle) dlclose (codecFuncHandle);
+ if (formatFuncHandle) dlclose(formatFuncHandle);
+ if (codecFuncHandle) dlclose(codecFuncHandle);
return ret;
}
-static void _unload_dynamic_functions (MMFILE_FUNC_HANDLE* pHandle)
+static void _unload_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
{
#ifdef __MMFILE_TEST_MODE__
debug_fenter();
#endif
- if (pHandle->formatFuncHandle)
- {
- dlclose (pHandle->formatFuncHandle);
+ if (pHandle->formatFuncHandle) {
+ dlclose(pHandle->formatFuncHandle);
}
- if (pHandle->codecFuncHandle)
- {
- dlclose (pHandle->codecFuncHandle);
+ if (pHandle->codecFuncHandle) {
+ dlclose(pHandle->codecFuncHandle);
}
#ifdef __MMFILE_TEST_MODE__
* local functions.
*/
static int
-_is_file_exist (const char *filename)
+_is_file_exist(const char *filename)
{
int ret = 1;
if (filename) {
- const char* to_access = (strstr(filename,"file://")!=NULL)? filename+7:filename;
- ret = access (to_access, R_OK );
+ const char *to_access = (strstr(filename, "file://") != NULL) ? filename + 7 : filename;
+ ret = access(to_access, R_OK);
if (ret != 0) {
- debug_error ("file [%s] not found.\n", to_access);
+ debug_error("file [%s] not found.\n", to_access);
}
}
return !ret;
}
static int
-_info_set_attr_media (mmf_attrs_t *attrs, MMFileFormatContext *formatContext)
+_info_set_attr_media(mmf_attrs_t *attrs, MMFileFormatContext *formatContext)
{
int ret = 0;
MMHandleType hattrs = CAST_MM_HANDLE(attrs);
- if (formatContext->commandType == MM_FILE_TAG)
- {
+ if (formatContext->commandType == MM_FILE_TAG) {
if (formatContext->title) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TITLE, formatContext->title);
if (formatContext->artist) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ARTIST, formatContext->artist);
if (formatContext->author) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->author);
- if (formatContext->composer && formatContext->author == NULL)
- mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
+ if (formatContext->composer && formatContext->author == NULL)
+ mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
if (formatContext->album) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM, formatContext->album);
if (formatContext->album_artist) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM_ARTIST, formatContext->album_artist);
if (formatContext->copyright) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COPYRIGHT, formatContext->copyright);
if (formatContext->comment) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COMMENT, formatContext->comment);
if (formatContext->genre) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_GENRE, formatContext->genre);
if (formatContext->classification) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CLASSIFICATION, formatContext->classification);
- if (formatContext->year) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DATE, formatContext->year);
- if (formatContext->tagTrackNum) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TRACK_NUM, formatContext->tagTrackNum);
+ if (formatContext->year) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DATE, formatContext->year);
+ if (formatContext->tagTrackNum) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TRACK_NUM, formatContext->tagTrackNum);
if (formatContext->rating) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_RATING, formatContext->rating);
if (formatContext->conductor) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CONDUCTOR, formatContext->conductor);
if (formatContext->recDate) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_RECDATE, formatContext->recDate);
if (formatContext->rotate) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ROTATE, formatContext->rotate);
- mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LONGITUDE, formatContext->longitude);
- mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LATIDUE, formatContext->latitude);
- mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_ALTIDUE, formatContext->altitude);
- mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS_NUM, formatContext->syncLyricsNum);
- mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_CDIS, formatContext->cdis);
- mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SMTA, formatContext->smta);
+ mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LONGITUDE, formatContext->longitude);
+ mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LATIDUE, formatContext->latitude);
+ mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_ALTIDUE, formatContext->altitude);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS_NUM, formatContext->syncLyricsNum);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_CDIS, formatContext->cdis);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SMTA, formatContext->smta);
if ((formatContext->syncLyricsNum > 0) && (formatContext->syncLyrics))
- mm_attrs_set_data_by_name (hattrs, MM_FILE_TAG_SYNCLYRICS, formatContext->syncLyrics, formatContext->syncLyricsNum);
+ mm_attrs_set_data_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS, formatContext->syncLyrics, formatContext->syncLyricsNum);
if (formatContext->unsyncLyrics) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_UNSYNCLYRICS, formatContext->unsyncLyrics);
if (formatContext->artwork && formatContext->artworkSize > 0) {
void *artworkCopy = NULL;
- artworkCopy = mmfile_malloc ((formatContext->artworkSize));
- if ( NULL != artworkCopy ) {
- memcpy (artworkCopy, formatContext->artwork, formatContext->artworkSize);
- mm_attrs_set_data_by_name (hattrs, MM_FILE_TAG_ARTWORK,artworkCopy, formatContext->artworkSize);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
+ artworkCopy = mmfile_malloc((formatContext->artworkSize));
+ if (NULL != artworkCopy) {
+ memcpy(artworkCopy, formatContext->artwork, formatContext->artworkSize);
+ mm_attrs_set_data_by_name(hattrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
if (formatContext->artworkMime) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
}
}
- }
- else if (formatContext->commandType == MM_FILE_CONTENTS)
- {
+ } else if (formatContext->commandType == MM_FILE_CONTENTS) {
/*get duration*/
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_DURATION, formatContext->duration);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_AUDIO_TRACK_COUNT, formatContext->audioTotalTrackNum);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, formatContext->videoTotalTrackNum);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_DURATION, formatContext->duration);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_TRACK_COUNT, formatContext->audioTotalTrackNum);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, formatContext->videoTotalTrackNum);
if (formatContext->videoTotalTrackNum > 0 &&
- formatContext->nbStreams > 0 &&
- formatContext->streams[MMFILE_VIDEO_STREAM]) {
+ formatContext->nbStreams > 0 &&
+ formatContext->streams[MMFILE_VIDEO_STREAM]) {
MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_CODEC, videoStream->codecId);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_BITRATE, videoStream->bitRate);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_FPS, videoStream->framePerSec);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, videoStream->width);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, videoStream->height);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_CODEC, videoStream->codecId);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_BITRATE, videoStream->bitRate);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_FPS, videoStream->framePerSec);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, videoStream->width);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, videoStream->height);
if (formatContext->thumbNail && formatContext->thumbNail->frameData) {
void *thumbNailCopy = NULL;
- thumbNailCopy = mmfile_malloc (formatContext->thumbNail->frameSize);
+ thumbNailCopy = mmfile_malloc(formatContext->thumbNail->frameSize);
if (NULL != thumbNailCopy) {
- memcpy (thumbNailCopy, formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
- mm_attrs_set_data_by_name (hattrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
+ memcpy(thumbNailCopy, formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
+ mm_attrs_set_data_by_name(hattrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
}
}
}
if (formatContext->audioTotalTrackNum > 0 &&
- formatContext->nbStreams > 0 &&
- formatContext->streams[MMFILE_AUDIO_STREAM]) {
+ formatContext->nbStreams > 0 &&
+ formatContext->streams[MMFILE_AUDIO_STREAM]) {
MMFileFormatStream *audioStream = formatContext->streams[MMFILE_AUDIO_STREAM];
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_AUDIO_CODEC, audioStream->codecId);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_AUDIO_CHANNELS, audioStream->nbChannel);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_AUDIO_BITRATE, audioStream->bitRate);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_AUDIO_SAMPLERATE, audioStream->samplePerSec);
- mm_attrs_set_int_by_name (hattrs, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, audioStream->bitPerSample);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_CODEC, audioStream->codecId);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_CHANNELS, audioStream->nbChannel);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_BITRATE, audioStream->bitRate);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_SAMPLERATE, audioStream->samplePerSec);
+ mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, audioStream->bitPerSample);
}
- }
- else
- {
+ } else {
ret = -1;
}
/*commit attrs*/
- ret = mmf_attrs_commit ((MMHandleType)hattrs);
+ ret = mmf_attrs_commit((MMHandleType)hattrs);
return ret;
}
static int
-_get_contents_info (mmf_attrs_t *attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
+_get_contents_info(mmf_attrs_t *attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
{
MMFileFormatContext *formatContext = NULL;
MMFileCodecContext *codecContext = NULL;
- MMFileFormatFrame frameContext = {0,};
- MMFileCodecFrame codecFrame = {0,};
- MMFileCodecFrame decodedFrame = {0,};
+ MMFileFormatFrame frameContext = {0, };
+ MMFileCodecFrame codecFrame = {0, };
+ MMFileCodecFrame decodedFrame = {0, };
int ret = 0;
-
+
if (!src || !parse)
return MM_ERROR_FILE_INTERNAL;
- ret = mmfile_format_open (&formatContext, src);
+ ret = mmfile_format_open(&formatContext, src);
if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
- debug_error ("error: mmfile_format_open\n");
+ debug_error("error: mmfile_format_open\n");
ret = MM_ERROR_FILE_INTERNAL;
goto exception;
}
if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL) {
if (parse->type == MM_FILE_PARSE_TYPE_SAFE)
formatContext->cdis = 1;
- ret = mmfile_format_read_stream (formatContext);
+ ret = mmfile_format_read_stream(formatContext);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error ("error: mmfile_format_read_stream\n");
+ debug_error("error: mmfile_format_read_stream\n");
ret = MM_ERROR_FILE_INTERNAL;
goto exception;
}
parse->video_track_num = formatContext->videoTotalTrackNum;
/* check uhqa content*/
- if (parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM] != NULL)
+ if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL) {
parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa;
-
- if (parse->type >= MM_FILE_PARSE_TYPE_ALL) {
+ } else {
+ parse->is_uhqa = FALSE;
+ }
+
+ if (parse->type >= MM_FILE_PARSE_TYPE_ALL) {
if (formatContext->videoTotalTrackNum > 0) {
if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
- if (formatContext->formatType == MM_FILE_FORMAT_3GP ||formatContext->formatType == MM_FILE_FORMAT_MP4) {
- MMFileUtilGetMetaDataFromMP4 (formatContext);
+ if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
+ MMFileUtilGetMetaDataFromMP4(formatContext);
}
}
MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
unsigned int timestamp = _SEEK_POINT_;
- ret = mmfile_format_read_frame (formatContext, timestamp, &frameContext);
+ ret = mmfile_format_read_frame(formatContext, timestamp, &frameContext);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error ("error: mmfile_format_read_frame\n");
+ debug_error("error: mmfile_format_read_frame\n");
ret = MM_ERROR_FILE_INTERNAL;
goto warning;
}
codecFrame.configData = frameContext.configData;
codecFrame.version = videoStream->version;
- ret = mmfile_codec_open (&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame);
+ ret = mmfile_codec_open(&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error ("error: mmfile_codec_open\n");
+ debug_error("error: mmfile_codec_open\n");
ret = MM_ERROR_FILE_INTERNAL;
goto warning;
}
- ret = mmfile_codec_decode (codecContext, &decodedFrame);
+ ret = mmfile_codec_decode(codecContext, &decodedFrame);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error ("error: mmfile_codec_decode\n");
+ debug_error("error: mmfile_codec_decode\n");
ret = MM_ERROR_FILE_INTERNAL;
goto warning;
}
-
+
/* set video thumbnail */
- formatContext->thumbNail = mmfile_malloc (sizeof(MMFileFormatFrame));
+ formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
if (NULL == formatContext->thumbNail) {
- debug_error ("error: mmfile_malloc\n");
+ debug_error("error: mmfile_malloc\n");
ret = MM_ERROR_FILE_INTERNAL;
goto warning;
}
formatContext->thumbNail->configLenth = 0;
formatContext->thumbNail->configData = NULL;
} else {
- formatContext->thumbNail = mmfile_malloc (sizeof(MMFileFormatFrame));
+ formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
if (NULL == formatContext->thumbNail) {
- debug_error ("error: mmfile_format_read_frame\n");
+ debug_error("error: mmfile_format_read_frame\n");
ret = MM_ERROR_FILE_INTERNAL;
goto warning;
}
}
#ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_frame (&frameContext);
+ mmfile_format_print_frame(&frameContext);
#endif
formatContext->commandType = MM_FILE_CONTENTS;
if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
- _info_set_attr_media (attrs, formatContext);
+ _info_set_attr_media(attrs, formatContext);
if (frameContext.bCompressed) {
- if (frameContext.frameData) mmfile_free (frameContext.frameData);
- if (frameContext.configData) mmfile_free (frameContext.configData);
+ if (frameContext.frameData) mmfile_free(frameContext.frameData);
+ if (frameContext.configData) mmfile_free(frameContext.configData);
if (decodedFrame.frameData) {
- mmfile_free (decodedFrame.frameData);
+ mmfile_free(decodedFrame.frameData);
formatContext->thumbNail->frameData = NULL;
}
if (decodedFrame.configData) {
- mmfile_free (decodedFrame.configData);
+ mmfile_free(decodedFrame.configData);
formatContext->thumbNail->configData = NULL;
}
} else {
if (frameContext.frameData) {
- mmfile_free (frameContext.frameData);
+ mmfile_free(frameContext.frameData);
formatContext->thumbNail->frameData = NULL;
}
if (frameContext.configData) {
- mmfile_free (frameContext.configData);
+ mmfile_free(frameContext.configData);
formatContext->thumbNail->configData = NULL;
}
}
- if (formatContext) { mmfile_format_close (formatContext); }
- if (codecContext) { mmfile_codec_close (codecContext); }
+ if (formatContext) {
+ mmfile_format_close(formatContext);
+ }
+ if (codecContext) {
+ mmfile_codec_close(codecContext);
+ }
return MM_ERROR_NONE;
if (frameContext.bCompressed) {
if (frameContext.frameData)
- mmfile_free (frameContext.frameData);
+ mmfile_free(frameContext.frameData);
- if (frameContext.configData)
- mmfile_free (frameContext.configData);
+ if (frameContext.configData)
+ mmfile_free(frameContext.configData);
if (decodedFrame.frameData) {
- mmfile_free (decodedFrame.frameData);
+ mmfile_free(decodedFrame.frameData);
formatContext->thumbNail->frameData = NULL;
}
if (decodedFrame.configData) {
- mmfile_free (decodedFrame.configData);
+ mmfile_free(decodedFrame.configData);
formatContext->thumbNail->configData = NULL;
}
} else {
if (frameContext.frameData) {
- mmfile_free (frameContext.frameData);
+ mmfile_free(frameContext.frameData);
formatContext->thumbNail->frameData = NULL;
}
-
+
if (frameContext.configData) {
- mmfile_free (frameContext.configData);
+ mmfile_free(frameContext.configData);
formatContext->thumbNail->configData = NULL;
}
}
if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
- _info_set_attr_media (attrs, formatContext);
+ _info_set_attr_media(attrs, formatContext);
- if (formatContext) { mmfile_format_close (formatContext); }
- if (codecContext) { mmfile_codec_close (codecContext); }
+ if (formatContext) {
+ mmfile_format_close(formatContext);
+ }
+ if (codecContext) {
+ mmfile_codec_close(codecContext);
+ }
return MM_ERROR_NONE;
exception:
if (frameContext.bCompressed) {
if (frameContext.frameData)
- mmfile_free (frameContext.frameData);
+ mmfile_free(frameContext.frameData);
- if (frameContext.configData)
- mmfile_free (frameContext.configData);
+ if (frameContext.configData)
+ mmfile_free(frameContext.configData);
if (decodedFrame.frameData) {
- mmfile_free (decodedFrame.frameData);
+ mmfile_free(decodedFrame.frameData);
formatContext->thumbNail->frameData = NULL;
}
if (decodedFrame.configData) {
- mmfile_free (decodedFrame.configData);
+ mmfile_free(decodedFrame.configData);
formatContext->thumbNail->configData = NULL;
}
} else {
if (frameContext.frameData) {
- mmfile_free (frameContext.frameData);
+ mmfile_free(frameContext.frameData);
formatContext->thumbNail->frameData = NULL;
}
-
+
if (frameContext.configData) {
- mmfile_free (frameContext.configData);
+ mmfile_free(frameContext.configData);
formatContext->thumbNail->configData = NULL;
}
}
- if (formatContext) { mmfile_format_close (formatContext); }
- // if (codecContext) { mmfile_codec_close (codecContext); } /*dead code*/
+ if (formatContext) {
+ mmfile_format_close(formatContext);
+ }
+ /* if (codecContext) { mmfile_codec_close(codecContext); } */ /*dead code*/
return ret;
}
static int
-_get_tag_info (mmf_attrs_t *attrs, MMFileSourceType *src)
+_get_tag_info(mmf_attrs_t *attrs, MMFileSourceType *src)
{
MMFileFormatContext *formatContext = NULL;
int ret = 0;
- ret = mmfile_format_open (&formatContext, src);
+ ret = mmfile_format_open(&formatContext, src);
if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
- debug_error ("error: mmfile_format_open\n");
+ debug_error("error: mmfile_format_open\n");
ret = MM_ERROR_FILE_INTERNAL;
goto exception;
}
- ret = mmfile_format_read_tag (formatContext);
+ ret = mmfile_format_read_tag(formatContext);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_warning ("reading tag is fail\n");
+ debug_warning("reading tag is fail\n");
ret = MM_ERROR_FILE_INTERNAL;
goto exception;
}
formatContext->commandType = MM_FILE_TAG;
- _info_set_attr_media (attrs, formatContext);
+ _info_set_attr_media(attrs, formatContext);
- if (formatContext) { mmfile_format_close (formatContext); }
+ if (formatContext) {
+ mmfile_format_close(formatContext);
+ }
return MM_ERROR_NONE;
exception:
- if (formatContext) { mmfile_format_close (formatContext); }
+ if (formatContext) {
+ mmfile_format_close(formatContext);
+ }
return MM_ERROR_FILE_INTERNAL;
}
int ret = MM_ERROR_NONE;
va_list var_args;
- if ( !attrs )
- {
- debug_error ("Invalid arguments [attrs 0]\n");
+ if (!attrs) {
+ debug_error("Invalid arguments [attrs 0]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
-
- if ( first_attribute_name == NULL)
- {
- debug_error ("Invalid arguments [first_attribute_name null]\n");
+
+ if (first_attribute_name == NULL) {
+ debug_error("Invalid arguments [first_attribute_name null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
/* get requested attributes */
- va_start (var_args, first_attribute_name);
+ va_start(var_args, first_attribute_name);
ret = mm_attrs_get_valist(attrs, err_attr_name, first_attribute_name, var_args);
- va_end (var_args);
+ va_end(var_args);
- if (ret != MM_ERROR_NONE)
- {
- if (err_attr_name)
- {
- debug_error ("failed to get %s\n", *err_attr_name);
+ if (ret != MM_ERROR_NONE) {
+ if (err_attr_name) {
+ debug_error("failed to get %s\n", *err_attr_name);
}
}
int mm_file_get_synclyrics_info(MMHandleType tag_attrs, int index, unsigned long *time_info, char **lyrics)
{
int ret = MM_ERROR_NONE;
- AvSynclyricsInfo* sync_lyric_item = NULL;
+ AvSynclyricsInfo *sync_lyric_item = NULL;
GList *synclyrics_list = NULL;
#ifdef __MMFILE_TEST_MODE__
debug_fenter();
#endif
- if ( (mmf_attrs_t*)tag_attrs == NULL) {
- debug_error ("invalid handle");
+ if ((mmf_attrs_t *)tag_attrs == NULL) {
+ debug_error("invalid handle");
return MM_ERROR_INVALID_ARGUMENT;
}
- ret = mm_attrs_get_data_by_name (tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
- if(ret != MM_ERROR_NONE) {
- #ifdef __MMFILE_TEST_MODE__
- debug_warning ( "get data fail");
- #endif
+ ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
+ if (ret != MM_ERROR_NONE) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_warning("get data fail");
+#endif
return ret;
}
-
- if(synclyrics_list != NULL) {
- sync_lyric_item = (AvSynclyricsInfo*)g_list_nth_data(synclyrics_list, index);
+ if (synclyrics_list != NULL) {
- if(sync_lyric_item == NULL) {
- #ifdef __MMFILE_TEST_MODE__
- debug_warning ( "synclyric item is NULL");
- #endif
+ sync_lyric_item = (AvSynclyricsInfo *)g_list_nth_data(synclyrics_list, index);
+
+ if (sync_lyric_item == NULL) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_warning("synclyric item is NULL");
+#endif
return MM_ERROR_COMMON_ATTR_NOT_EXIST;
}
*lyrics = sync_lyric_item->lyric_info;
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_warning ( "synclyrics_list is NULL");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_warning("synclyrics_list is NULL");
+#endif
return MM_ERROR_COMMON_ATTR_NOT_EXIST;
}
/* Check argument here */
if (tag_attrs == NULL) {
- debug_error ("Invalid arguments [tag null]\n");
+ debug_error("Invalid arguments [tag null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
if (filename == NULL) {
- debug_error ("Invalid arguments [filename null]\n");
+ debug_error("Invalid arguments [filename null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
- if ( strlen (filename) == 0) {
- debug_error ("Invalid arguments [filename size 0]\n");
+ if (strlen(filename) == 0) {
+ debug_error("Invalid arguments [filename size 0]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
-
- ret = _load_dynamic_functions (&func_handle);
+
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
/*set source file infomation*/
- MM_FILE_SET_MEDIA_FILE_SRC (src, filename);
+ MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
- ret = _is_file_exist (filename);
+ ret = _is_file_exist(filename);
if (!ret) {
ret = MM_ERROR_FILE_NOT_FOUND;
goto END;
}
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("tag", g_tag_attrs, ARRAY_SIZE (g_tag_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("tag", g_tag_attrs, ARRAY_SIZE(g_tag_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
- ret = _get_tag_info (attrs, &src);
+ ret = _get_tag_info(attrs, &src);
if (ret != MM_ERROR_NONE) {
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error ("failed to get tag: %s\n", filename);
+ debug_error("failed to get tag: %s\n", filename);
}
*tag_attrs = (MMHandleType)attrs;
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
debug_fenter();
#endif
- if ( (mmf_attrs_t*)tag_attrs == NULL) {
- debug_error ("invalid handle.\n");
+ if ((mmf_attrs_t *)tag_attrs == NULL) {
+ debug_error("invalid handle.\n");
return MM_ERROR_INVALID_ARGUMENT;
}
- ret = mm_attrs_get_data_by_name (tag_attrs, MM_FILE_TAG_ARTWORK, &artwork);
+ ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_ARTWORK, &artwork);
if (artwork != NULL) {
- mmfile_free (artwork);
+ mmfile_free(artwork);
}
- ret = mm_attrs_get_data_by_name (tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
+ ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
- if(synclyrics_list != NULL) {
+ if (synclyrics_list != NULL) {
mm_file_free_synclyrics_list(synclyrics_list);
}
- mmf_attrs_free (tag_attrs);
+ mmf_attrs_free(tag_attrs);
#ifdef __MMFILE_TEST_MODE__
debug_fleave();
}
EXPORT_API
-int mm_file_create_content_attrs (MMHandleType *contents_attrs, const char *filename)
+int mm_file_create_content_attrs(MMHandleType *contents_attrs, const char *filename)
{
mmf_attrs_t *attrs = NULL;
- MMFileSourceType src = {0,};
- MMFILE_PARSE_INFO parse = {0,};
+ MMFileSourceType src = {0, };
+ MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
#ifdef __MMFILE_TEST_MODE__
/* Check argument here */
if (contents_attrs == NULL) {
- debug_error ("Invalid arguments [contents null]\n");
+ debug_error("Invalid arguments [contents null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
if (filename == NULL) {
- debug_error ("Invalid arguments [filename null]\n");
+ debug_error("Invalid arguments [filename null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
- if ( strlen (filename) == 0) {
- debug_error ("Invalid arguments [filename size 0]\n");
+ if (strlen(filename) == 0) {
+ debug_error("Invalid arguments [filename size 0]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- #ifdef CHECK_TIME
- int64_t ti;
+#ifdef CHECK_TIME
+ int64_t ti;
ti = gettime();
- #endif
+#endif
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
- #ifdef CHECK_TIME
+#ifdef CHECK_TIME
debug_msg("_load_dynamic_functions() = %lld\n", gettime() - ti);
- #endif
+#endif
#endif
/*set source file infomation*/
- MM_FILE_SET_MEDIA_FILE_SRC (src, filename);
+ MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
- ret = _is_file_exist (filename);
+ ret = _is_file_exist(filename);
if (!ret) {
ret = MM_ERROR_FILE_NOT_FOUND;
goto END;
}
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("content", g_content_attrs, ARRAY_SIZE (g_content_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
parse.type = MM_FILE_PARSE_TYPE_ALL;
- ret = _get_contents_info (attrs, &src, &parse);
+ ret = _get_contents_info(attrs, &src, &parse);
if (ret != MM_ERROR_NONE) {
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error ("failed to get contents: %s\n", filename);
+ debug_error("failed to get contents: %s\n", filename);
}
*contents_attrs = (MMHandleType) attrs;
END:
#ifdef __MMFILE_DYN_LOADING__
- #ifdef CHECK_TIME
+#ifdef CHECK_TIME
ti = gettime();
- #endif
+#endif
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
- #ifdef CHECK_TIME
+#ifdef CHECK_TIME
debug_msg("_unload_dynamic_functions() = %lld\n", gettime() - ti);
- #endif
+#endif
#endif
EXPORT_API
-int mm_file_create_tag_attrs_from_memory (MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
+int mm_file_create_tag_attrs_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
{
mmf_attrs_t *attrs = NULL;
MMFileSourceType src;
- MMFILE_PARSE_INFO parse = {0,};
+ /*MMFILE_PARSE_INFO parse = {0, };*/
int ret = 0;
#ifdef __MMFILE_TEST_MODE__
/* Check argument here */
if (tag_attrs == NULL || data == NULL) {
- debug_error ("Invalid arguments\n");
+ debug_error("Invalid arguments\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
- MM_FILE_SET_MEDIA_MEM_SRC (src, data, size, format);
+ MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("tag", g_tag_attrs, ARRAY_SIZE (g_tag_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("tag", g_tag_attrs, ARRAY_SIZE(g_tag_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
- parse.type = MM_FILE_PARSE_TYPE_ALL;
- ret = _get_tag_info (attrs, &src);
+ /*parse.type = MM_FILE_PARSE_TYPE_ALL;*/
+ ret = _get_tag_info(attrs, &src);
if (ret != MM_ERROR_NONE) {
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error ("failed to get tag");
+ debug_error("failed to get tag");
}
*tag_attrs = (MMHandleType)attrs;
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
EXPORT_API
-int mm_file_create_content_attrs_from_memory (MMHandleType *contents_attrs, const void *data, unsigned int size, int format)
+int mm_file_create_content_attrs_from_memory(MMHandleType *contents_attrs, const void *data, unsigned int size, int format)
{
mmf_attrs_t *attrs = NULL;
MMFileSourceType src;
- MMFILE_PARSE_INFO parse = {0,};
+ MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
#ifdef __MMFILE_TEST_MODE__
/* Check argument here */
if (contents_attrs == NULL || data == NULL) {
- debug_error ("Invalid arguments\n");
+ debug_error("Invalid arguments\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
- MM_FILE_SET_MEDIA_MEM_SRC (src, data, size, format);
+ MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("content", g_content_attrs, ARRAY_SIZE (g_content_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
parse.type = MM_FILE_PARSE_TYPE_ALL;
- ret = _get_contents_info (attrs, &src, &parse);
+ ret = _get_contents_info(attrs, &src, &parse);
if (ret != MM_ERROR_NONE) {
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error ("failed to get contents");
+ debug_error("failed to get contents");
}
*contents_attrs = (MMHandleType)attrs;
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
EXPORT_API
-int mm_file_destroy_content_attrs (MMHandleType contents_attrs)
+int mm_file_destroy_content_attrs(MMHandleType contents_attrs)
{
void *thumbnail = NULL;
int ret = MM_ERROR_NONE;
debug_fenter();
#endif
- if ((mmf_attrs_t*)contents_attrs == NULL) {
- debug_error ("invalid handle.\n");
+ if ((mmf_attrs_t *)contents_attrs == NULL) {
+ debug_error("invalid handle.\n");
return MM_ERROR_INVALID_ARGUMENT;
}
ret = mm_attrs_get_data_by_name(contents_attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &thumbnail);
if (thumbnail != NULL) {
- mmfile_free (thumbnail);
+ mmfile_free(thumbnail);
}
- mmf_attrs_free (contents_attrs);
+ mmf_attrs_free(contents_attrs);
#ifdef __MMFILE_TEST_MODE__
debug_fleave();
EXPORT_API
-int mm_file_get_stream_info(const char* filename, int *audio_stream_num, int *video_stream_num)
+int mm_file_get_stream_info(const char *filename, int *audio_stream_num, int *video_stream_num)
{
- MMFileSourceType src = {0,};
- MMFILE_PARSE_INFO parse = {0,};
+ MMFileSourceType src = {0, };
+ MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
debug_fenter();
#endif
- if (filename == NULL || strlen (filename) == 0 || audio_stream_num == NULL || video_stream_num == NULL) {
- debug_error ("Invalid arguments\n");
+ if (filename == NULL || strlen(filename) == 0 || audio_stream_num == NULL || video_stream_num == NULL) {
+ debug_error("Invalid arguments\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
/*set source file infomation*/
- MM_FILE_SET_MEDIA_FILE_SRC (src, filename);
+ MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
- ret = _is_file_exist (filename);
+ ret = _is_file_exist(filename);
if (!ret) {
ret = MM_ERROR_FILE_NOT_FOUND;
goto END;
}
parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
- ret = _get_contents_info (NULL, &src, &parse);
+ ret = _get_contents_info(NULL, &src, &parse);
if (ret != MM_ERROR_NONE) {
- debug_error ("failed to get stream info: %s\n", filename);
+ debug_error("failed to get stream info: %s\n", filename);
} else {
- if(parse.audio_track_num == 0 && parse.video_track_num == 0) {
- debug_error ("empty header. retry to get stream info: %s\n", filename);
+ if (parse.audio_track_num == 0 && parse.video_track_num == 0) {
+ debug_error("empty header. retry to get stream info: %s\n", filename);
parse.type = MM_FILE_PARSE_TYPE_NORMAL;
- ret = _get_contents_info (NULL, &src, &parse);
+ ret = _get_contents_info(NULL, &src, &parse);
}
}
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
int mm_file_create_content_attrs_simple(MMHandleType *contents_attrs, const char *filename)
{
mmf_attrs_t *attrs = NULL;
- MMFileSourceType src = {0,};
- MMFILE_PARSE_INFO parse = {0,};
+ MMFileSourceType src = {0, };
+ MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
#ifdef __MMFILE_TEST_MODE__
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
ret = MM_ERROR_INVALID_ARGUMENT;
goto END;
} else {
- if (strlen (filename) == 0) {
+ if (strlen(filename) == 0) {
ret = MM_ERROR_INVALID_ARGUMENT;
goto END;
}
}
/*set source file infomation*/
- MM_FILE_SET_MEDIA_FILE_SRC (src, filename);
+ MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
- ret = _is_file_exist (filename);
+ ret = _is_file_exist(filename);
if (!ret) {
ret = MM_ERROR_FILE_NOT_FOUND;
goto END;
}
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("content", g_content_attrs, ARRAY_SIZE (g_content_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
parse.type = MM_FILE_PARSE_TYPE_NORMAL;
- ret = _get_contents_info (attrs, &src, &parse);
+ ret = _get_contents_info(attrs, &src, &parse);
if (ret != MM_ERROR_NONE) {
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error ("failed to get contents: %s\n", filename);
+ debug_error("failed to get contents: %s\n", filename);
}
*contents_attrs = (MMHandleType) attrs;
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
int mm_file_create_content_attrs_safe(MMHandleType *contents_attrs, const char *filename)
{
mmf_attrs_t *attrs = NULL;
- MMFileSourceType src = {0,};
- MMFILE_PARSE_INFO parse = {0,};
+ MMFileSourceType src = {0, };
+ MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
#ifdef __MMFILE_TEST_MODE__
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
ret = MM_ERROR_INVALID_ARGUMENT;
goto END;
} else {
- if (strlen (filename) == 0) {
+ if (strlen(filename) == 0) {
ret = MM_ERROR_INVALID_ARGUMENT;
goto END;
}
}
/*set source file infomation*/
- MM_FILE_SET_MEDIA_FILE_SRC (src, filename);
+ MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
- ret = _is_file_exist (filename);
+ ret = _is_file_exist(filename);
if (!ret) {
ret = MM_ERROR_FILE_NOT_FOUND;
goto END;
}
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("content", g_content_attrs, ARRAY_SIZE (g_content_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
parse.type = MM_FILE_PARSE_TYPE_SAFE;
- ret = _get_contents_info (attrs, &src, &parse);
+ ret = _get_contents_info(attrs, &src, &parse);
if (ret != MM_ERROR_NONE) {
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error ("failed to get contents: %s\n", filename);
+ debug_error("failed to get contents: %s\n", filename);
}
*contents_attrs = (MMHandleType) attrs;
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
}
EXPORT_API
-int mm_file_get_video_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
+int mm_file_get_video_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
int ret = 0;
void *formatFuncHandle = NULL;
if (path == NULL) {
- debug_error ("Invalid arguments [Path is Null]\n");
+ debug_error("Invalid arguments [Path is Null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
/* Get from function argument */
- formatFuncHandle = dlopen (MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
+ formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
if (!formatFuncHandle) {
- debug_error ("error : dlopen");
+ debug_error("error : dlopen");
goto exception;
}
- mmfile_format_get_frame = dlsym (formatFuncHandle, "mmfile_format_get_frame");
- if ( !mmfile_format_get_frame ) {
- debug_error ("error : load library");
+ mmfile_format_get_frame = dlsym(formatFuncHandle, "mmfile_format_get_frame");
+ if (!mmfile_format_get_frame) {
+ debug_error("error : load library");
goto exception;
}
#endif
ret = mmfile_format_get_frame(path, timestamp, is_accurate, frame, size, width, height);
if (ret == MMFILE_FORMAT_FAIL) {
- debug_error ("error : get frame");
+ debug_error("error : get frame");
goto exception;
}
- if (formatFuncHandle) dlclose (formatFuncHandle);
+ if (formatFuncHandle) dlclose(formatFuncHandle);
return MM_ERROR_NONE;
exception:
- if (formatFuncHandle) dlclose (formatFuncHandle);
+ if (formatFuncHandle) dlclose(formatFuncHandle);
return MM_ERROR_FILE_INTERNAL;
}
void *formatFuncHandle = NULL;
if (data == NULL) {
- debug_error ("Invalid arguments [data is Null]\n");
+ debug_error("Invalid arguments [data is Null]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
if (datasize == 0) {
- debug_error ("Invalid arguments [datasize is zero]\n");
+ debug_error("Invalid arguments [datasize is zero]\n");
return MM_ERROR_INVALID_ARGUMENT;
}
#ifdef __MMFILE_DYN_LOADING__
/* Get from function argument */
- formatFuncHandle = dlopen (MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
+ formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
if (!formatFuncHandle) {
- debug_error ("error : dlopen");
+ debug_error("error : dlopen");
goto exception;
}
- mmfile_format_get_frame_from_memory = dlsym (formatFuncHandle, "mmfile_format_get_frame_from_memory");
- if ( !mmfile_format_get_frame_from_memory ) {
- debug_error ("error : load library");
+ mmfile_format_get_frame_from_memory = dlsym(formatFuncHandle, "mmfile_format_get_frame_from_memory");
+ if (!mmfile_format_get_frame_from_memory) {
+ debug_error("error : load library");
goto exception;
}
#endif
ret = mmfile_format_get_frame_from_memory(data, datasize, timestamp, is_accurate, frame, size, width, height);
if (ret == MMFILE_FORMAT_FAIL) {
- debug_error ("error : get frame");
+ debug_error("error : get frame");
goto exception;
}
- if (formatFuncHandle) dlclose (formatFuncHandle);
+ if (formatFuncHandle) dlclose(formatFuncHandle);
return MM_ERROR_NONE;
exception:
- if (formatFuncHandle) dlclose (formatFuncHandle);
+ if (formatFuncHandle) dlclose(formatFuncHandle);
return MM_ERROR_FILE_INTERNAL;
}
EXPORT_API
-int mm_file_check_uhqa(const char* filename, bool *is_uhqa)
+int mm_file_check_uhqa(const char *filename, bool *is_uhqa)
{
mmf_attrs_t *attrs = NULL;
- MMFileSourceType src = {0,};
- MMFILE_PARSE_INFO parse = {0,};
+ MMFileSourceType src = {0, };
+ MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
- ret = _load_dynamic_functions (&func_handle);
+ ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error ("load library error\n");
+ debug_error("load library error\n");
return MM_ERROR_FILE_INTERNAL;
}
#endif
ret = MM_ERROR_INVALID_ARGUMENT;
goto END;
} else {
- if (strlen (filename) == 0) {
+ if (strlen(filename) == 0) {
ret = MM_ERROR_INVALID_ARGUMENT;
goto END;
}
}
/*set source file infomation*/
- MM_FILE_SET_MEDIA_FILE_SRC (src, filename);
+ MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
- ret = _is_file_exist (filename);
+ ret = _is_file_exist(filename);
if (!ret) {
ret = MM_ERROR_FILE_NOT_FOUND;
goto END;
}
/*set attrs*/
- attrs = (mmf_attrs_t *) mmf_attrs_new_from_data ("content", g_content_attrs, ARRAY_SIZE (g_content_attrs), NULL, NULL);
+ attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
if (!attrs) {
- debug_error ("attribute internal error.\n");
+ debug_error("attribute internal error.\n");
ret = MM_ERROR_FILE_INTERNAL;
goto END;
}
parse.type = MM_FILE_PARSE_TYPE_NORMAL;
- ret = _get_contents_info (attrs, &src, &parse);
+ ret = _get_contents_info(attrs, &src, &parse);
if (ret == MM_ERROR_NONE) {
*is_uhqa = parse.is_uhqa;
} else {
- debug_error ("_get_contents_info failed\n");
+ debug_error("_get_contents_info failed\n");
*is_uhqa = FALSE;
}
- mmf_attrs_free ((MMHandleType)attrs);
+ mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
END:
#ifdef __MMFILE_DYN_LOADING__
- _unload_dynamic_functions (&func_handle);
+ _unload_dynamic_functions(&func_handle);
#endif
#ifdef __MMFILE_TEST_MODE__
Name: libmm-fileinfo
Summary: Media Fileinfo
-Version: 0.6.32
+Version: 0.6.33
Release: 0
Group: System/Libraries
License: Apache-2.0
cp %{SOURCE1001} .
%build
+export CFLAGS+=" -Wextra -Wno-array-bounds"
+export CFLAGS+=" -Wno-ignored-qualifiers -Wno-unused-parameter -Wshadow"
+export CFLAGS+=" -Wwrite-strings -Wswitch-default -Werror"
+export CFLAGS+=" -Wno-int-to-pointer-cast"
CFLAGS="${CFLAGS} -D_MM_PROJECT_FLOATER -DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" "
export CFLAGS
-int get_address (char *linebuff, char *ptrbuff)
+int get_address(char *linebuff, char *ptrbuff)
{
- char *head = linebuff;
+ char *head = linebuff;
- if (!linebuff || !ptrbuff)
- return 0;
+ if (!linebuff || !ptrbuff)
+ return 0;
- head = head + PREFIX_STRING_LEN;
+ head = head + PREFIX_STRING_LEN;
- while (*head != ' ')
- {
- *ptrbuff = *head;
- ptrbuff++;
- head++;
- }
+ while (*head != ' ') {
+ *ptrbuff = *head;
+ ptrbuff++;
+ head++;
+ }
- return 1;
+ return 1;
}
-int main (int argc, char *argv[])
+int main(int argc, char *argv[])
{
- char linebuffer[LINE_BUFFER_LEN];
- char ptrbuffer[ADDR_BUFFER_LEN];
-
- int alloccount = 0;
- int freecount = 0;
-
- if (argc != 2)
- {
- printf ("Usage: ./memtrace-read memtrace.mtr\n");
- exit (1);
- }
-
- FILE *fp1 = fopen (argv[1], "r");
- FILE *fp2 = fopen ("memtrace-result.txt", "w");
-
- if (!fp1 || !fp2)
- {
- printf ("fail to open %s\n", argv[1]);
- exit (1);
- }
-
- while (1)
- {
- memset (linebuffer, 0x00, LINE_BUFFER_LEN);
- memset (ptrbuffer, 0x00, ADDR_BUFFER_LEN);
-
- if (fgets (linebuffer, LINE_BUFFER_LEN, fp1) == NULL)
- break;
-
- if (memcmp (MALLOC_STRING, linebuffer, PREFIX_STRING_LEN) == 0)
- {
- get_address (linebuffer, ptrbuffer);
- alloccount++;
- }
-
- if (memcmp (FREE_STRING, linebuffer, PREFIX_STRING_LEN) == 0)
- {
- get_address (linebuffer, ptrbuffer);
- freecount++;
- }
- }
-
- if (alloccount != freecount)
- {
- char alloclist[alloccount][ADDR_BUFFER_LEN];
- int alloccountlist[alloccount];
- char freelist[freecount][ADDR_BUFFER_LEN];
- int freecountlist[freecount];
-
- int i = 0;
- int allocindex = 0;
- int freeindex = 0;
- int totalcount = 0;
-
- memset (alloclist, 0x00, alloccount*ADDR_BUFFER_LEN);
- memset (alloccountlist, 0x00, alloccount*4);
-
- memset (freelist, 0x00, freecount*ADDR_BUFFER_LEN);
- memset (freecountlist, 0x00, freecount*4);
-
- fseek (fp1, 0, SEEK_SET);
-
- while (1)
- {
- memset (linebuffer, 0x00, LINE_BUFFER_LEN);
- memset (ptrbuffer, 0x00, ADDR_BUFFER_LEN);
-
- if (fgets (linebuffer, LINE_BUFFER_LEN, fp1) == NULL)
- break;
-
- totalcount++;
- if (memcmp (MALLOC_STRING, linebuffer, PREFIX_STRING_LEN) == 0)
- {
- int i = 0;
-
- get_address (linebuffer, ptrbuffer);
-
- for (i = 0; i < alloccount; i++)
- {
- if (memcmp (ptrbuffer, alloclist[i], strlen(ptrbuffer)) == 0)
- {
- alloccountlist[i]++;
- break;
- }
- }
-
- if ( i == alloccount)
- {
- memcpy (alloclist[allocindex], ptrbuffer, strlen(ptrbuffer));
- alloccountlist[allocindex]++;
- allocindex++;
- }
- }
-
- if (memcmp (FREE_STRING, linebuffer, PREFIX_STRING_LEN) == 0)
- {
- int i = 0;
-
- get_address (linebuffer, ptrbuffer);
-
- for (i = 0; i < freecount; i++)
- {
- if (memcmp (ptrbuffer, freelist[i], strlen(ptrbuffer)) == 0)
- {
- freecountlist[i]++;
- break;
- }
- }
-
- if ( i == freecount)
- {
- memcpy (freelist[freeindex], ptrbuffer, strlen(ptrbuffer));
- freecountlist[freeindex]++;
- freeindex++;
- }
- }
- }
-
- printf ("Total: %d mem operation\n", totalcount);
-
- int i1 = 0, i2 = 0;
-
-
- fprintf (fp2, "-------------------------------------------------------------\n");
- fprintf (fp2, "ADDRESS (malloc count, free cout, diff)\n");
-
-
- for ( i1 = 0; i1 < allocindex; i1++)
- {
- for (i2 = 0; i2 < freeindex; i2++)
- {
- if (strcmp (alloclist[i1], freelist[i2]) == 0)
- {
- if (strcmp (alloclist[i1], "Checked") != 0)
- break;
- }
- }
-
- if (i2 == freeindex)
- {
- // fprintf (fp2, "%s error\n", alloclist[i1]);
- }
- else
- {
- fprintf (fp2, "%s %12d %8d %8d\n", alloclist[i1], alloccountlist[i1], freecountlist[i2], alloccountlist[i1] - freecountlist[i2]);
- strcpy (alloclist[i1], "Checked");
- strcpy (freelist[i2], "Checked");
- }
- }
-
- for (i = 0; i < allocindex; i++)
- {
- if ( strcmp (alloclist[i], "Checked") != 0 )
- fprintf (fp2, "%s error\n", alloclist[i]);
- }
-
- for (i = 0; i < freeindex; i++)
- {
- if ( strcmp (freelist[i], "Checked") != 0 )
- fprintf (fp2, "%s error\n", freelist[i]);
- }
- }
-
- fclose (fp1);
- fclose (fp2);
-
- exit (0);
+ char linebuffer[LINE_BUFFER_LEN];
+ char ptrbuffer[ADDR_BUFFER_LEN];
+
+ int alloccount = 0;
+ int freecount = 0;
+
+ if (argc != 2) {
+ printf("Usage: ./memtrace-read memtrace.mtr\n");
+ exit(1);
+ }
+
+ FILE *fp1 = fopen(argv[1], "r");
+ FILE *fp2 = fopen("memtrace-result.txt", "w");
+
+ if (!fp1 || !fp2) {
+ printf("fail to open %s\n", argv[1]);
+ exit(1);
+ }
+
+ while (1) {
+ memset(linebuffer, 0x00, LINE_BUFFER_LEN);
+ memset(ptrbuffer, 0x00, ADDR_BUFFER_LEN);
+
+ if (fgets(linebuffer, LINE_BUFFER_LEN, fp1) == NULL)
+ break;
+
+ if (memcmp(MALLOC_STRING, linebuffer, PREFIX_STRING_LEN) == 0) {
+ get_address(linebuffer, ptrbuffer);
+ alloccount++;
+ }
+
+ if (memcmp(FREE_STRING, linebuffer, PREFIX_STRING_LEN) == 0) {
+ get_address(linebuffer, ptrbuffer);
+ freecount++;
+ }
+ }
+
+ if (alloccount != freecount) {
+ char alloclist[alloccount][ADDR_BUFFER_LEN];
+ int alloccountlist[alloccount];
+ char freelist[freecount][ADDR_BUFFER_LEN];
+ int freecountlist[freecount];
+
+ int i = 0;
+ int allocindex = 0;
+ int freeindex = 0;
+ int totalcount = 0;
+
+ memset(alloclist, 0x00, alloccount * ADDR_BUFFER_LEN);
+ memset(alloccountlist, 0x00, alloccount * 4);
+
+ memset(freelist, 0x00, freecount * ADDR_BUFFER_LEN);
+ memset(freecountlist, 0x00, freecount * 4);
+
+ fseek(fp1, 0, SEEK_SET);
+
+ while (1) {
+ memset(linebuffer, 0x00, LINE_BUFFER_LEN);
+ memset(ptrbuffer, 0x00, ADDR_BUFFER_LEN);
+
+ if (fgets(linebuffer, LINE_BUFFER_LEN, fp1) == NULL)
+ break;
+
+ totalcount++;
+ if (memcmp(MALLOC_STRING, linebuffer, PREFIX_STRING_LEN) == 0) {
+ int i = 0;
+
+ get_address(linebuffer, ptrbuffer);
+
+ for (i = 0; i < alloccount; i++) {
+ if (memcmp(ptrbuffer, alloclist[i], strlen(ptrbuffer)) == 0) {
+ alloccountlist[i]++;
+ break;
+ }
+ }
+
+ if (i == alloccount) {
+ memcpy(alloclist[allocindex], ptrbuffer, strlen(ptrbuffer));
+ alloccountlist[allocindex]++;
+ allocindex++;
+ }
+ }
+
+ if (memcmp(FREE_STRING, linebuffer, PREFIX_STRING_LEN) == 0) {
+ int i = 0;
+
+ get_address(linebuffer, ptrbuffer);
+
+ for (i = 0; i < freecount; i++) {
+ if (memcmp(ptrbuffer, freelist[i], strlen(ptrbuffer)) == 0) {
+ freecountlist[i]++;
+ break;
+ }
+ }
+
+ if (i == freecount) {
+ memcpy(freelist[freeindex], ptrbuffer, strlen(ptrbuffer));
+ freecountlist[freeindex]++;
+ freeindex++;
+ }
+ }
+ }
+
+ printf("Total: %d mem operation\n", totalcount);
+
+ int i1 = 0, i2 = 0;
+
+
+ fprintf(fp2, "-------------------------------------------------------------\n");
+ fprintf(fp2, "ADDRESS (malloc count, free cout, diff)\n");
+
+
+ for (i1 = 0; i1 < allocindex; i1++) {
+ for (i2 = 0; i2 < freeindex; i2++) {
+ if (strcmp(alloclist[i1], freelist[i2]) == 0) {
+ if (strcmp(alloclist[i1], "Checked") != 0)
+ break;
+ }
+ }
+
+ if (i2 == freeindex) {
+ /* fprintf (fp2, "%s error\n", alloclist[i1]); */
+ } else {
+ fprintf(fp2, "%s %12d %8d %8d\n", alloclist[i1], alloccountlist[i1], freecountlist[i2], alloccountlist[i1] - freecountlist[i2]);
+ strcpy(alloclist[i1], "Checked");
+ strcpy(freelist[i2], "Checked");
+ }
+ }
+
+ for (i = 0; i < allocindex; i++) {
+ if (strcmp(alloclist[i], "Checked") != 0)
+ fprintf(fp2, "%s error\n", alloclist[i]);
+ }
+
+ for (i = 0; i < freeindex; i++) {
+ if (strcmp(freelist[i], "Checked") != 0)
+ fprintf(fp2, "%s error\n", freelist[i]);
+ }
+ }
+
+ fclose(fp1);
+ fclose(fp2);
+
+ exit(0);
}
#include "mm_file_traverse.h"
#define MM_TIME_CHECK_START \
-{ FILE *msg_tmp_fp = fopen("time_check.txt", "a+"); struct timeval start, finish; gettimeofday(&start, NULL);
+ { FILE *msg_tmp_fp = fopen("time_check.txt", "a+"); struct timeval start, finish; gettimeofday(&start, NULL);
#define MM_TIME_CHECK_FINISH(title) \
-gettimeofday(&finish, NULL); \
-double end_time = (finish.tv_sec + 1e-6*finish.tv_usec); \
-double start_time = (start.tv_sec + 1e-6*start.tv_usec); \
-if(msg_tmp_fp != NULL) { \
-fprintf(msg_tmp_fp, "%s\n", title); \
-fprintf(msg_tmp_fp, " - start_time: %3.5lf sec\n", start_time); \
-fprintf(msg_tmp_fp, " - finish_time: %3.5lf sec\n", end_time); \
-fprintf(msg_tmp_fp, " - elapsed time: %3.5lf sec\n", end_time - start_time); \
-fflush(msg_tmp_fp); fclose(msg_tmp_fp); }}
+ gettimeofday(&finish, NULL); \
+ double end_time = (finish.tv_sec + 1e-6*finish.tv_usec); \
+ double start_time = (start.tv_sec + 1e-6*start.tv_usec); \
+ if (msg_tmp_fp != NULL) { \
+ fprintf(msg_tmp_fp, "%s\n", title); \
+ fprintf(msg_tmp_fp, " - start_time: %3.5lf sec\n", start_time); \
+ fprintf(msg_tmp_fp, " - finish_time: %3.5lf sec\n", end_time); \
+ fprintf(msg_tmp_fp, " - elapsed time: %3.5lf sec\n", end_time - start_time); \
+ fflush(msg_tmp_fp); fclose(msg_tmp_fp); }}
typedef struct _mmfile_value {
int len;
double d_val;
char *s_val;
void *p_val;
- }value;
-}mmfile_value_t;
+ } value;
+} mmfile_value_t;
typedef struct _TagContext {
mmfile_value_t artist;
mmfile_value_t genre;
mmfile_value_t author;
mmfile_value_t copyright;
- mmfile_value_t date; //string
- mmfile_value_t recdate; //string
+ mmfile_value_t date; /*string */
+ mmfile_value_t recdate; /*string */
mmfile_value_t description;
mmfile_value_t comment;
- mmfile_value_t artwork; //data
- mmfile_value_t artwork_size; //int
+ mmfile_value_t artwork; /*data */
+ mmfile_value_t artwork_size; /*int */
mmfile_value_t artwork_mime;
mmfile_value_t track_num;
mmfile_value_t classfication;
mmfile_value_t rating;
mmfile_value_t conductor;
- mmfile_value_t longitude; //-> double
- mmfile_value_t latitude;
- mmfile_value_t altitude; //<-double
+ mmfile_value_t longitude; /*-> double */
+ mmfile_value_t latitude;
+ mmfile_value_t altitude; /*<-double */
mmfile_value_t unsynclyrics;
mmfile_value_t synclyrics_size;
- mmfile_value_t rotate; //string
-}TagContext_t;
+ mmfile_value_t rotate; /*string */
+} TagContext_t;
typedef struct _ContentContext {
int duration;
int audio_track_num;
int audio_bitpersample;
mmfile_value_t thumbnail;
-}ContentContext_t;
-
-
-char * AudioCodecTypeString [] = {
- "AMR", "G723.1", "MP3", "OGG", "AAC", "WMA", "MMF", "ADPCM", "WAVE", "WAVE NEW", // 0~9
- "MIDI", "IMELODY", "MXMF", "MPEG1-Layer1 codec", "MPEG1-Layer2 codec", // 10~14
- "G711", "G722", "G722.1", "G722.2 (AMR-WB)", "G723 wideband speech", // 15~19
- "G726 (ADPCM)", "G728 speech", "G729", "G729a", "G729.1", // 20~24
- "Real", "AAC-Low complexity", "AAC-Main profile", "AAC-Scalable sample rate", "AAC-Long term prediction", // 25~29
- "AAC-High Efficiency v1", "AAC-High efficiency v2", "DolbyDigital", "Apple Lossless", "Sony proprietary", // 30~34
- "SPEEX", "Vorbis", "AIFF", "AU", "None (will be deprecated)", //35~39
- "PCM", "ALAW", "MULAW", "MS ADPCM", "FLAC" // 40~44
+} ContentContext_t;
+
+
+const char *AudioCodecTypeString[] = {
+ "AMR", "G723.1", "MP3", "OGG", "AAC", "WMA", "MMF", "ADPCM", "WAVE", "WAVE NEW", /* 0~9 */
+ "MIDI", "IMELODY", "MXMF", "MPEG1-Layer1 codec", "MPEG1-Layer2 codec", /* 10~14 */
+ "G711", "G722", "G722.1", "G722.2 (AMR-WB)", "G723 wideband speech", /* 15~19 */
+ "G726 (ADPCM)", "G728 speech", "G729", "G729a", "G729.1", /* 20~24 */
+ "Real", "AAC-Low complexity", "AAC-Main profile", "AAC-Scalable sample rate", "AAC-Long term prediction", /* 25~29 */
+ "AAC-High Efficiency v1", "AAC-High efficiency v2", "DolbyDigital", "Apple Lossless", "Sony proprietary", /* 30~34 */
+ "SPEEX", "Vorbis", "AIFF", "AU", "None (will be deprecated)", /*35~39 */
+ "PCM", "ALAW", "MULAW", "MS ADPCM", "FLAC" /* 40~44 */
};
-char * VideoCodecTypeString [] = {
- "None (will be deprecated)", // 0
- "H263", "H264", "H26L", "MPEG4", "MPEG1", // 1~5
- "WMV", "DIVX", "XVID", "H261", "H262/MPEG2-part2", // 6~10
- "H263v2", "H263v3", "Motion JPEG", "MPEG2", "MPEG4 part-2 Simple profile", // 11~15
- "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
- "MPEG4 part-10 (h.264)", "Real", "VC-1", "AVS", "Cinepak", // 21~25
- "Indeo", "Theora", "Flv" // 26~28
+const char *VideoCodecTypeString[] = {
+ "None (will be deprecated)", /* 0 */
+ "H263", "H264", "H26L", "MPEG4", "MPEG1", /* 1~5 */
+ "WMV", "DIVX", "XVID", "H261", "H262/MPEG2-part2", /* 6~10 */
+ "H263v2", "H263v3", "Motion JPEG", "MPEG2", "MPEG4 part-2 Simple profile", /* 11~15 */
+ "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 */
+ "MPEG4 part-10 (h.264)", "Real", "VC-1", "AVS", "Cinepak", /* 21~25 */
+ "Indeo", "Theora", "Flv" /* 26~28 */
};
FILE *fpFailList = NULL;
-static int mmfile_get_file_infomation (void *data, void* user_data, bool file_test);
+static int mmfile_get_file_infomation(void *data, void *user_data, bool file_test);
-inline static int mm_file_is_little_endian (void)
+inline static int mm_file_is_little_endian(void)
{
- int i = 0x00000001;
- return ((char *)&i)[0];
+ int i = 0x00000001;
+ return ((char *)&i)[0];
}
#define READ_FROM_FILE(FILE_PATH, data, size) \
-do{ \
- FILE * fp = fopen (FILE_PATH, "r"); \
- if (fp) { \
- fseek (fp, 0, SEEK_END); \
+ do { \
+ FILE *fp = fopen(FILE_PATH, "r"); \
+ if (fp) { \
+ fseek(fp, 0, SEEK_END); \
size = ftell(fp); \
- fseek (fp, 0, SEEK_SET); \
- if(size > 0) data = malloc (size); \
- if(data != NULL ) { if (fread (data, size, sizeof(char), fp) != size) { printf("fread error\n"); } } \
- fclose (fp); \
- printf("file size = %d\n", size ); \
- } \
-}while(0)
+ fseek(fp, 0, SEEK_SET); \
+ if (size > 0) data = malloc(size); \
+ if (data != NULL) { if (fread(data, size, sizeof(char), fp) != size) { printf("fread error\n"); } } \
+ fclose(fp); \
+ printf("file size = %d\n", size); \
+ } \
+ } while (0)
static int
-_is_file_exist (const char *filename)
+_is_file_exist(const char *filename)
{
int ret = 1;
if (filename) {
- const char* to_access = (strstr(filename,"file://")!=NULL)? filename+7:filename;
- ret = access (to_access, R_OK );
+ const char *to_access = (strstr(filename, "file://") != NULL) ? filename + 7 : filename;
+ ret = access(to_access, R_OK);
if (ret != 0) {
- printf ("file [%s] not found.\n", to_access);
+ printf("file [%s] not found.\n", to_access);
}
}
return !ret;
int main(int argc, char **argv)
{
- struct stat statbuf;
- bool file_test = true; //if you want to test mm_file_create_content_XXX_from_memory() set file_test to false
-
- if (_is_file_exist (argv[1])) {
- int ret = lstat (argv[1], &statbuf);
- if ( ret < 0 ) {
- printf ("lstat error[%d]\n", ret);
- return MMFILE_FAIL;
- }
+ struct stat statbuf;
+ bool file_test = true; /*if you want to test mm_file_create_content_XXX_from_memory() set file_test to false */
+
+ if (_is_file_exist(argv[1])) {
+ int ret = lstat(argv[1], &statbuf);
+ if (ret < 0) {
+ printf("lstat error[%d]\n", ret);
+ return MMFILE_FAIL;
+ }
if (fpFailList == NULL) {
- fpFailList = fopen ("/opt/var/log/mmfile_fails.txt", "w");
+ fpFailList = fopen("/opt/var/log/mmfile_fails.txt", "w");
}
- if ( S_ISDIR (statbuf.st_mode) ) {
- mmfile_get_file_names (argv[1], mmfile_get_file_infomation, NULL);
+ if (S_ISDIR(statbuf.st_mode)) {
+ mmfile_get_file_names(argv[1], mmfile_get_file_infomation, NULL);
} else {
- mmfile_get_file_infomation (argv[1], NULL, file_test);
+ mmfile_get_file_infomation(argv[1], NULL, file_test);
}
if (fpFailList != NULL) {
- fflush (fpFailList);
- fclose (fpFailList);
+ fflush(fpFailList);
+ fclose(fpFailList);
}
- }
+ }
- return 0;//exit(0);
+ return 0;/*exit(0); */
}
-static int mmfile_get_file_infomation (void *data, void* user_data, bool file_test)
+static int mmfile_get_file_infomation(void *data, void *user_data, bool file_test)
{
MMHandleType content_attrs = 0;
MMHandleType tag_attrs = 0;
int ret = 0;
char filename[512];
- memset (filename, 0x00, 512);
- memcpy (filename, (char*)data, strlen ((char*)data));
+ memset(filename, 0x00, 512);
+ memcpy(filename, (char *)data, strlen((char *)data));
MM_TIME_CHECK_START
- printf ("Extracting information for [%s] \n", filename);
+ printf("Extracting information for [%s] \n", filename);
/* get track info */
ret = mm_file_get_stream_info(filename, &audio_track_num, &video_track_num);
if (ret == MM_ERROR_NONE) {
- printf ("# audio=%d, video=%d\n", audio_track_num, video_track_num);
+ printf("# audio=%d, video=%d\n", audio_track_num, video_track_num);
} else {
- printf ("Failed to mm_file_get_stream_info() error=[%x]\n", ret);
+ printf("Failed to mm_file_get_stream_info() error=[%x]\n", ret);
}
- if(file_test) {
+ if (file_test) {
/* get content handle */
ret = mm_file_create_content_attrs(&content_attrs, filename);
} else {
- int file_size = 0;
- unsigned char * buffer = NULL;
+ unsigned int file_size = 0;
+ unsigned char *buffer = NULL;
/* Read file */
READ_FROM_FILE(filename, buffer, file_size);
- ret =mm_file_create_content_attrs_from_memory(&content_attrs, buffer, file_size, MM_FILE_FORMAT_3GP);
+ ret = mm_file_create_content_attrs_from_memory(&content_attrs, buffer, file_size, MM_FILE_FORMAT_3GP);
}
if (ret == MM_ERROR_NONE && content_attrs) {
ContentContext_t ccontent;
- memset (&ccontent, 0, sizeof (ContentContext_t));
+ memset(&ccontent, 0, sizeof(ContentContext_t));
ret = mm_file_get_attrs(content_attrs, &err_attr_name, MM_FILE_CONTENT_DURATION, &ccontent.duration, NULL);
printf("# duration: %d\n", ccontent.duration);
- if (ret != MM_ERROR_NONE && err_attr_name)
- {
+ if (ret != MM_ERROR_NONE && err_attr_name) {
printf("failed to get %s\n", err_attr_name);
free(err_attr_name);
err_attr_name = NULL;
}
- if (audio_track_num)
- {
+ if (audio_track_num) {
ret = mm_file_get_attrs(content_attrs,
- NULL,
- MM_FILE_CONTENT_AUDIO_CODEC, &ccontent.audio_codec,
- MM_FILE_CONTENT_AUDIO_SAMPLERATE, &ccontent.audio_samplerate,
- MM_FILE_CONTENT_AUDIO_BITRATE, &ccontent.audio_bitrate,
- MM_FILE_CONTENT_AUDIO_CHANNELS, &ccontent.audio_channel,
- MM_FILE_CONTENT_AUDIO_TRACK_INDEX, &ccontent.audio_track_id,
- MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &ccontent.audio_track_num,
- MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, &ccontent.audio_bitpersample,
- NULL);
-
- if(ret != MM_ERROR_NONE) {
+ NULL,
+ MM_FILE_CONTENT_AUDIO_CODEC, &ccontent.audio_codec,
+ MM_FILE_CONTENT_AUDIO_SAMPLERATE, &ccontent.audio_samplerate,
+ MM_FILE_CONTENT_AUDIO_BITRATE, &ccontent.audio_bitrate,
+ MM_FILE_CONTENT_AUDIO_CHANNELS, &ccontent.audio_channel,
+ MM_FILE_CONTENT_AUDIO_TRACK_INDEX, &ccontent.audio_track_id,
+ MM_FILE_CONTENT_AUDIO_TRACK_COUNT, &ccontent.audio_track_num,
+ MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, &ccontent.audio_bitpersample,
+ NULL);
+
+ if (ret != MM_ERROR_NONE) {
printf("failed to get audio attrs\n");
} else {
- printf ("[Audio] ----------------------------------------- \n");
+ printf("[Audio] ----------------------------------------- \n");
printf("# audio codec: %d ", ccontent.audio_codec);
- printf ("[%s]\n", (ccontent.audio_codec >= 0 && ccontent.audio_codec < MM_AUDIO_CODEC_NUM)? AudioCodecTypeString[ccontent.audio_codec] : "Invalid");
+ printf("[%s]\n", (ccontent.audio_codec >= 0 && ccontent.audio_codec < MM_AUDIO_CODEC_NUM) ? AudioCodecTypeString[ccontent.audio_codec] : "Invalid");
printf("# audio samplerate: %d Hz\n", ccontent.audio_samplerate);
printf("# audio bitrate: %d bps\n", ccontent.audio_bitrate);
printf("# audio channel: %d\n", ccontent.audio_channel);
printf("# audio bit per sample: %d\n", ccontent.audio_bitpersample);
}
}
-
- if (video_track_num)
- {
+
+ if (video_track_num) {
ret = mm_file_get_attrs(content_attrs,
- NULL,
- MM_FILE_CONTENT_VIDEO_CODEC, &ccontent.video_codec,
- MM_FILE_CONTENT_VIDEO_BITRATE, &ccontent.video_bitrate,
- MM_FILE_CONTENT_VIDEO_FPS, &ccontent.video_fps,
- MM_FILE_CONTENT_VIDEO_TRACK_INDEX, &ccontent.video_track_id,
- MM_FILE_CONTENT_VIDEO_WIDTH, &ccontent.video_w,
- MM_FILE_CONTENT_VIDEO_HEIGHT, &ccontent.video_h,
- MM_FILE_CONTENT_VIDEO_THUMBNAIL, &ccontent.thumbnail.value.p_val, &ccontent.thumbnail.len,
- NULL);
-
- if(ret != MM_ERROR_NONE) {
+ NULL,
+ MM_FILE_CONTENT_VIDEO_CODEC, &ccontent.video_codec,
+ MM_FILE_CONTENT_VIDEO_BITRATE, &ccontent.video_bitrate,
+ MM_FILE_CONTENT_VIDEO_FPS, &ccontent.video_fps,
+ MM_FILE_CONTENT_VIDEO_TRACK_INDEX, &ccontent.video_track_id,
+ MM_FILE_CONTENT_VIDEO_WIDTH, &ccontent.video_w,
+ MM_FILE_CONTENT_VIDEO_HEIGHT, &ccontent.video_h,
+ MM_FILE_CONTENT_VIDEO_THUMBNAIL, &ccontent.thumbnail.value.p_val, &ccontent.thumbnail.len,
+ NULL);
+
+ if (ret != MM_ERROR_NONE) {
printf("failed to get video attrs\n");
} else {
- printf ("[Video] ----------------------------------------- \n");
+ printf("[Video] ----------------------------------------- \n");
printf("# video codec: %d ", ccontent.video_codec);
- printf ("[%s]\n", (ccontent.video_codec >= 0 && ccontent.video_codec < MM_VIDEO_CODEC_NUM)? VideoCodecTypeString[ccontent.video_codec] : "Invalid");
+ printf("[%s]\n", (ccontent.video_codec >= 0 && ccontent.video_codec < MM_VIDEO_CODEC_NUM) ? VideoCodecTypeString[ccontent.video_codec] : "Invalid");
printf("# video bitrate: %d bps\n", ccontent.video_bitrate);
printf("# video fps: %d\n", ccontent.video_fps);
printf("# video track id: %d\n", ccontent.video_track_id);
mm_file_destroy_content_attrs(content_attrs);
} else {
- printf ("Failed to mm_file_create_content_attrs() error=[%x]\n", ret);
+ printf("Failed to mm_file_create_content_attrs() error=[%x]\n", ret);
}
- if(file_test) {
+ if (file_test) {
/* get tag handle */
ret = mm_file_create_tag_attrs(&tag_attrs, filename);
} else {
- int file_size = 0;
- unsigned char * buffer = NULL;
+ unsigned int file_size = 0;
+ unsigned char *buffer = NULL;
/* Read file */
READ_FROM_FILE(filename, buffer, file_size);
- ret =mm_file_create_tag_attrs_from_memory(&tag_attrs, buffer, file_size, MM_FILE_FORMAT_3GP);
+ ret = mm_file_create_tag_attrs_from_memory(&tag_attrs, buffer, file_size, MM_FILE_FORMAT_3GP);
}
if (ret == MM_ERROR_NONE && tag_attrs) {
TagContext_t ctag;
- memset (&ctag, 0, sizeof (TagContext_t));
+ memset(&ctag, 0, sizeof(TagContext_t));
/* get attributes of tag */
- ret = mm_file_get_attrs( tag_attrs,
- &err_attr_name,
- MM_FILE_TAG_ARTIST, &ctag.artist.value.s_val, &ctag.artist.len,
- MM_FILE_TAG_ALBUM, &ctag.album.value.s_val, &ctag.album.len,
- MM_FILE_TAG_ALBUM_ARTIST, &ctag.album_artist.value.s_val, &ctag.album_artist.len,
- MM_FILE_TAG_TITLE, &ctag.title.value.s_val, &ctag.title.len,
- MM_FILE_TAG_GENRE, &ctag.genre.value.s_val, &ctag.genre.len,
- MM_FILE_TAG_AUTHOR, &ctag.author.value.s_val, &ctag.author.len,
- MM_FILE_TAG_COPYRIGHT, &ctag.copyright.value.s_val, &ctag.copyright.len,
- MM_FILE_TAG_DATE, &ctag.date.value.s_val, &ctag.date.len,
- MM_FILE_TAG_RECDATE, &ctag.recdate.value.s_val, &ctag.recdate.len,
- MM_FILE_TAG_DESCRIPTION, &ctag.description.value.s_val, &ctag.description.len,
- MM_FILE_TAG_COMMENT, &ctag.comment.value.s_val, &ctag.comment.len,
- MM_FILE_TAG_ARTWORK, &ctag.artwork.value.p_val, &ctag.artwork.len,
- MM_FILE_TAG_ARTWORK_SIZE, &ctag.artwork_size.value.i_val,
- MM_FILE_TAG_ARTWORK_MIME, &ctag.artwork_mime.value.s_val, &ctag.artwork_mime.len,
- MM_FILE_TAG_TRACK_NUM, &ctag.track_num.value.s_val, &ctag.track_num.len,
- MM_FILE_TAG_CLASSIFICATION, &ctag.classfication.value.s_val, &ctag.classfication.len,
- MM_FILE_TAG_RATING, &ctag.rating.value.s_val, &ctag.rating.len,
- MM_FILE_TAG_LONGITUDE, &ctag.longitude.value.d_val,
- MM_FILE_TAG_LATIDUE, &ctag.latitude.value.d_val,
- MM_FILE_TAG_ALTIDUE, &ctag.altitude.value.d_val,
- MM_FILE_TAG_CONDUCTOR, &ctag.conductor.value.s_val, &ctag.conductor.len,
- MM_FILE_TAG_UNSYNCLYRICS, &ctag.unsynclyrics.value.s_val, &ctag.unsynclyrics.len,
- MM_FILE_TAG_SYNCLYRICS_NUM, &ctag.synclyrics_size.value.i_val,
- MM_FILE_TAG_ROTATE, &ctag.rotate.value.s_val, &ctag.rotate.len,
- NULL);
- if (ret != MM_ERROR_NONE && err_attr_name)
- {
+ ret = mm_file_get_attrs(tag_attrs,
+ &err_attr_name,
+ MM_FILE_TAG_ARTIST, &ctag.artist.value.s_val, &ctag.artist.len,
+ MM_FILE_TAG_ALBUM, &ctag.album.value.s_val, &ctag.album.len,
+ MM_FILE_TAG_ALBUM_ARTIST, &ctag.album_artist.value.s_val, &ctag.album_artist.len,
+ MM_FILE_TAG_TITLE, &ctag.title.value.s_val, &ctag.title.len,
+ MM_FILE_TAG_GENRE, &ctag.genre.value.s_val, &ctag.genre.len,
+ MM_FILE_TAG_AUTHOR, &ctag.author.value.s_val, &ctag.author.len,
+ MM_FILE_TAG_COPYRIGHT, &ctag.copyright.value.s_val, &ctag.copyright.len,
+ MM_FILE_TAG_DATE, &ctag.date.value.s_val, &ctag.date.len,
+ MM_FILE_TAG_RECDATE, &ctag.recdate.value.s_val, &ctag.recdate.len,
+ MM_FILE_TAG_DESCRIPTION, &ctag.description.value.s_val, &ctag.description.len,
+ MM_FILE_TAG_COMMENT, &ctag.comment.value.s_val, &ctag.comment.len,
+ MM_FILE_TAG_ARTWORK, &ctag.artwork.value.p_val, &ctag.artwork.len,
+ MM_FILE_TAG_ARTWORK_SIZE, &ctag.artwork_size.value.i_val,
+ MM_FILE_TAG_ARTWORK_MIME, &ctag.artwork_mime.value.s_val, &ctag.artwork_mime.len,
+ MM_FILE_TAG_TRACK_NUM, &ctag.track_num.value.s_val, &ctag.track_num.len,
+ MM_FILE_TAG_CLASSIFICATION, &ctag.classfication.value.s_val, &ctag.classfication.len,
+ MM_FILE_TAG_RATING, &ctag.rating.value.s_val, &ctag.rating.len,
+ MM_FILE_TAG_LONGITUDE, &ctag.longitude.value.d_val,
+ MM_FILE_TAG_LATIDUE, &ctag.latitude.value.d_val,
+ MM_FILE_TAG_ALTIDUE, &ctag.altitude.value.d_val,
+ MM_FILE_TAG_CONDUCTOR, &ctag.conductor.value.s_val, &ctag.conductor.len,
+ MM_FILE_TAG_UNSYNCLYRICS, &ctag.unsynclyrics.value.s_val, &ctag.unsynclyrics.len,
+ MM_FILE_TAG_SYNCLYRICS_NUM, &ctag.synclyrics_size.value.i_val,
+ MM_FILE_TAG_ROTATE, &ctag.rotate.value.s_val, &ctag.rotate.len,
+ NULL);
+ if (ret != MM_ERROR_NONE && err_attr_name) {
printf("failed to get %s attrs\n", err_attr_name);
free(err_attr_name);
err_attr_name = NULL;
- if (msg_tmp_fp) /* opened by MM_TIME_CHECK_START */
- {
- fclose (msg_tmp_fp);
+ if (msg_tmp_fp) { /* opened by MM_TIME_CHECK_START */
+ fclose(msg_tmp_fp);
msg_tmp_fp = NULL;
}
mm_file_destroy_tag_attrs(tag_attrs);
}
/* print tag information */
- printf ("[Tag] =================================== \n");
+ printf("[Tag] =================================== \n");
printf("# artist: [%s]\n", ctag.artist.value.s_val);
printf("# title: [%s]\n", ctag.title.value.s_val);
printf("# album: [%s]\n", ctag.album.value.s_val);
printf("# synclyrics size: [%d]\n", ctag.synclyrics_size.value.i_val);
printf("# rotate: [%s]\n", ctag.rotate.value.s_val);
- if(ctag.synclyrics_size.value.i_val > 0) {
+ if (ctag.synclyrics_size.value.i_val > 0) {
int idx = 0;
unsigned long time_info = 0;
- char * lyrics_info = NULL;
+ char *lyrics_info = NULL;
printf("# synclyrics: \n");
-
- for(idx = 0; idx < ctag.synclyrics_size.value.i_val; idx++) {
+
+ for (idx = 0; idx < ctag.synclyrics_size.value.i_val; idx++) {
ret = mm_file_get_synclyrics_info(tag_attrs, idx, &time_info, &lyrics_info);
- if(ret == MM_ERROR_NONE) {
+ if (ret == MM_ERROR_NONE) {
printf("[%2d][%6ld][%s]\n", idx, time_info, lyrics_info);
} else {
printf("Error when get lyrics\n");
}
}
}
-
+
/* release tag */
ret = mm_file_destroy_tag_attrs(tag_attrs);
if (ret != MM_ERROR_NONE) {
printf("Error mm_file_destroy_tag_attrs: %d", ret);
if (msg_tmp_fp) {
- fclose (msg_tmp_fp);
+ fclose(msg_tmp_fp);
msg_tmp_fp = NULL;
}
return -1;
}
} else {
- printf ("Failed to mm_file_create_tag_attrs() error=[%x]\n", ret);
+ printf("Failed to mm_file_create_tag_attrs() error=[%x]\n", ret);
}
- printf ("=================================================\n\n");
+ printf("=================================================\n\n");
- MM_TIME_CHECK_FINISH (filename);
+ MM_TIME_CHECK_FINISH(filename);
- return 0;
+ return 0;
}
#define MMFILE_PATH_MAX 256
-typedef enum
-{
+typedef enum {
MMFILE_FAIL = 0,
- MMFILE_SUCCESS
+ MMFILE_SUCCESS
} MMFILE_RETURN;
-typedef int (*MMFunc) (void *data, void* user_data, bool file_test);
+typedef int (*MMFunc)(void *data, void *user_data, bool file_test);
-int mmfile_get_file_names (char *root_dir, MMFunc cbfunc, void* user_data);
+int mmfile_get_file_names(char *root_dir, MMFunc cbfunc, void *user_data);
#endif /* _MM_FILE_TRAVERSE_H_ */
static GList *g_directories = NULL;
-int mmfile_get_file_names (char *root_dir, MMFunc cbfunc, void* user_data)
+int mmfile_get_file_names(char *root_dir, MMFunc cbfunc, void *user_data)
{
struct stat statbuf;
struct dirent dirp;
struct dirent *result = NULL;
DIR *dp;
- char pdirname[MMFILE_PATH_MAX+1];
+ char pdirname[MMFILE_PATH_MAX + 1];
- memset (pdirname, 0x00, MMFILE_PATH_MAX+1);
-
- if ( lstat (root_dir, &statbuf) < 0 )
- {
- printf ("lstat error\n");
+ memset(pdirname, 0x00, MMFILE_PATH_MAX + 1);
+
+ if (lstat(root_dir, &statbuf) < 0) {
+ printf("lstat error\n");
return MMFILE_FAIL;
}
- if ( S_ISDIR (statbuf.st_mode) == 0 )
- {
- printf ("it is not directory\n");
+ if (S_ISDIR(statbuf.st_mode) == 0) {
+ printf("it is not directory\n");
return MMFILE_FAIL;
}
- g_directories = g_list_append(g_directories, strdup (root_dir));
+ g_directories = g_list_append(g_directories, strdup(root_dir));
int i = 0;
gpointer element_data = NULL;
- while ( (element_data = g_list_nth_data (g_directories, i)) != NULL )
- {
- if (strlen ((char*) element_data) > 0 && strlen ((char*) element_data) <= MMFILE_PATH_MAX)
- {
- strncpy (pdirname, (char*) element_data, strlen((char*) element_data));
-
- if ( (dp = opendir (pdirname)) != NULL )
- {
- while (!readdir_r(dp, &dirp, &result))
- {
- char cdirname[MMFILE_PATH_MAX+1];
-
- if ( strcmp (dirp.d_name, ".") == 0 ||
- strcmp (dirp.d_name, "..") == 0 )
- {
+ while ((element_data = g_list_nth_data(g_directories, i)) != NULL) {
+ if (strlen((char *) element_data) > 0 && strlen((char *) element_data) <= MMFILE_PATH_MAX) {
+ strncpy(pdirname, (char *) element_data, strlen((char *) element_data));
+
+ if ((dp = opendir(pdirname)) != NULL) {
+ while (!readdir_r(dp, &dirp, &result)) {
+ char cdirname[MMFILE_PATH_MAX + 1];
+
+ if (strcmp(dirp.d_name, ".") == 0 ||
+ strcmp(dirp.d_name, "..") == 0) {
continue;
}
- memset (cdirname, 0x00, MMFILE_PATH_MAX+1);
- strncpy (cdirname, pdirname, strlen(pdirname));
- strncat (cdirname, "/", 1);
- strncat (cdirname, dirp.d_name, strlen(dirp.d_name));
-
- if ( lstat (cdirname, &statbuf) < 0 )
- {
- printf ("lstat error\n");
- closedir (dp);
+ memset(cdirname, 0x00, MMFILE_PATH_MAX + 1);
+ strncpy(cdirname, pdirname, strlen(pdirname));
+ strncat(cdirname, "/", 1);
+ strncat(cdirname, dirp.d_name, strlen(dirp.d_name));
+
+ if (lstat(cdirname, &statbuf) < 0) {
+ printf("lstat error\n");
+ closedir(dp);
return MMFILE_FAIL;
}
- if ( S_ISDIR (statbuf.st_mode) )
- {
- printf ("directory: %s\n", cdirname);
- g_directories = g_list_append(g_directories, strdup (cdirname));
- }
- else
- {
- printf ("file: %s\n", cdirname);
- if ( cbfunc != NULL )
- {
- cbfunc (cdirname, user_data, true);
+ if (S_ISDIR(statbuf.st_mode)) {
+ printf("directory: %s\n", cdirname);
+ g_directories = g_list_append(g_directories, strdup(cdirname));
+ } else {
+ printf("file: %s\n", cdirname);
+ if (cbfunc != NULL) {
+ cbfunc(cdirname, user_data, true);
}
}
-
+
}
- closedir (dp);
+ closedir(dp);
}
}
i++;
}
- g_list_free (g_directories);
-
+ g_list_free(g_directories);
+
return MMFILE_SUCCESS;
-
-
+
+
}
#endif
-////////////////////////////////////////////////////////////////////////
-// ENDIAN UTIL API //
-////////////////////////////////////////////////////////////////////////
-inline unsigned int mmfile_io_be_uint32 (unsigned int value);
-inline unsigned int mmfile_io_le_uint32 (unsigned int value);
-inline int mmfile_io_be_int32 (unsigned int value);
-inline int mmfile_io_le_int32 (unsigned int value);
-inline unsigned short mmfile_io_be_uint16 (unsigned short value);
-inline unsigned short mmfile_io_le_uint16 (unsigned short value);
-inline short mmfile_io_be_int16 (unsigned short value);
-inline short mmfile_io_le_int16 (unsigned short value);
-
-typedef struct MMFileIOHandle
-{
- struct MMFileIOFunc *iofunc;
- int flags; /* file flags */
- void *privateData;
- char *fileName;
+/*////////////////////////////////////////////////////////////////////// */
+/* ENDIAN UTIL API // */
+/*////////////////////////////////////////////////////////////////////// */
+inline unsigned int mmfile_io_be_uint32(unsigned int value);
+inline unsigned int mmfile_io_le_uint32(unsigned int value);
+inline int mmfile_io_be_int32(unsigned int value);
+inline int mmfile_io_le_int32(unsigned int value);
+inline unsigned short mmfile_io_be_uint16(unsigned short value);
+inline unsigned short mmfile_io_le_uint16(unsigned short value);
+inline short mmfile_io_be_int16(unsigned short value);
+inline short mmfile_io_le_int16(unsigned short value);
+
+typedef struct MMFileIOHandle {
+ struct MMFileIOFunc *iofunc;
+ int flags; /* file flags */
+ void *privateData;
+ char *fileName;
} MMFileIOHandle;
-////////////////////////////////////////////////////////////////////////
-// FILE HEADER CHECK API //
-////////////////////////////////////////////////////////////////////////
-int MMFileFormatIsValidMP3 (MMFileIOHandle *pFileIO, const char *mmfileuri, int frameCnt);
-int MMFileFormatIsValidAAC (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidASF (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMP4 (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidAVI (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidAMR (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidWAV (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMMF (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMID (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidIMY (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidWMA (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidWMV (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidOGG (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidREAL(MMFileIOHandle *pFileIO, const char * mmfileuri);
-int MMFileFormatIsValidMatroska (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidQT (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidFLAC (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidFLV (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMPEGTS (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMPEGPS (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMPEGVIDEO (MMFileIOHandle *pFileIO, const char *mmfileuri);
-int MMFileFormatIsValidMPEGAUDIO (MMFileIOHandle *pFileIO, const char *mmfileuri);
-
-
-////////////////////////////////////////////////////////////////////////
-// IO HANDLER API //
-////////////////////////////////////////////////////////////////////////
+/*////////////////////////////////////////////////////////////////////// */
+/* FILE HEADER CHECK API // */
+/*////////////////////////////////////////////////////////////////////// */
+int MMFileFormatIsValidMP3(MMFileIOHandle *pFileIO, const char *mmfileuri, int frameCnt);
+int MMFileFormatIsValidAAC(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidASF(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMP4(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidAVI(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidAMR(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidWAV(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMMF(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMID(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidIMY(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidWMA(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidWMV(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidOGG(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidREAL(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMatroska(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidQT(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidFLAC(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidFLV(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMPEGTS(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMPEGPS(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMPEGVIDEO(MMFileIOHandle *pFileIO, const char *mmfileuri);
+int MMFileFormatIsValidMPEGAUDIO(MMFileIOHandle *pFileIO, const char *mmfileuri);
+
+
+/*////////////////////////////////////////////////////////////////////// */
+/* IO HANDLER API // */
+/*////////////////////////////////////////////////////////////////////// */
#define MMFILE_URI_MAX_LEN 512
#define MMFILE_FILE_URI "file://"
#define MMFILE_FILE_URI_LEN 7
#define MMFILE_SEEK_CUR SEEK_CUR
#define MMFILE_SEEK_END SEEK_END
-typedef struct MMFileIOFunc
-{
+typedef struct MMFileIOFunc {
const char *handleName;
- int (*mmfile_open) (MMFileIOHandle *h, const char *filename, int flags);
- int (*mmfile_read) (MMFileIOHandle *h, unsigned char *buf, int size);
- int (*mmfile_write)(MMFileIOHandle *h, unsigned char *buf, int size);
- long long (*mmfile_seek) (MMFileIOHandle *h, long long pos, int whence);
- long long (*mmfile_tell) (MMFileIOHandle *h);
- int (*mmfile_close)(MMFileIOHandle *h);
+ int (*mmfile_open)(MMFileIOHandle *h, const char *filename, int flags);
+ int (*mmfile_read)(MMFileIOHandle *h, unsigned char *buf, int size);
+ int (*mmfile_write)(MMFileIOHandle *h, unsigned char *buf, int size);
+ long long(*mmfile_seek)(MMFileIOHandle *h, long long pos, int whence);
+ long long(*mmfile_tell)(MMFileIOHandle *h);
+ int (*mmfile_close)(MMFileIOHandle *h);
struct MMFileIOFunc *next;
} MMFileIOFunc;
-int mmfile_register_io_func (MMFileIOFunc *iofunc);
-int mmfile_register_io_all ();
+int mmfile_register_io_func(MMFileIOFunc *iofunc);
+int mmfile_register_io_all();
-int mmfile_open (MMFileIOHandle **h, const char *filename, int flags);
-int mmfile_read (MMFileIOHandle *h, unsigned char *buf, int size);
+int mmfile_open(MMFileIOHandle **h, const char *filename, int flags);
+int mmfile_read(MMFileIOHandle *h, unsigned char *buf, int size);
int mmfile_write(MMFileIOHandle *h, unsigned char *buf, int size);
-long long mmfile_seek (MMFileIOHandle *h, long long pos, int whence);
-long long mmfile_tell (MMFileIOHandle *h);
+long long mmfile_seek(MMFileIOHandle *h, long long pos, int whence);
+long long mmfile_tell(MMFileIOHandle *h);
int mmfile_close(MMFileIOHandle *h);
-////////////////////////////////////////////////////////////////////////
-// MIME API //
-////////////////////////////////////////////////////////////////////////
+/*////////////////////////////////////////////////////////////////////// */
+/* MIME API // */
+/*////////////////////////////////////////////////////////////////////// */
#define MMFILE_FILE_FMT_MAX_LEN 25
#define MMFILE_MIMETYPE_MAX_LEN 40
#define MMFILE_FILE_EXT_MAX_LEN 7
-int mmfile_util_get_ffmpeg_format (const char *mime, char *ffmpegFormat);
-int mmfile_util_get_file_ext (const char *mime, char *ext);
+int mmfile_util_get_ffmpeg_format(const char *mime, char *ffmpegFormat);
+int mmfile_util_get_file_ext(const char *mime, char *ext);
-////////////////////////////////////////////////////////////////////////
-// PRINT API //
-////////////////////////////////////////////////////////////////////////
-void mmfile_format_print_contents (MMFileFormatContext*in);
-void mmfile_format_print_tags (MMFileFormatContext*in);
-void mmfile_codec_print (MMFileCodecContext *in);
-void mmfile_format_print_frame (MMFileFormatFrame *in);
+/*////////////////////////////////////////////////////////////////////// */
+/* PRINT API // */
+/*////////////////////////////////////////////////////////////////////// */
+void mmfile_format_print_contents(MMFileFormatContext *in);
+void mmfile_format_print_tags(MMFileFormatContext *in);
+void mmfile_codec_print(MMFileCodecContext *in);
+void mmfile_format_print_frame(MMFileFormatFrame *in);
-////////////////////////////////////////////////////////////////////////
-// STRING API //
-////////////////////////////////////////////////////////////////////////
-char **mmfile_strsplit (const char *string, const char *delimiter);
-void mmfile_strfreev (char **str_array);
-int mmfile_util_wstrlen (unsigned short *wText);
-short* mmfile_swap_2byte_string (short* mszOutput, short* mszInput, int length);
+/*////////////////////////////////////////////////////////////////////// */
+/* STRING API // */
+/*////////////////////////////////////////////////////////////////////// */
+char **mmfile_strsplit(const char *string, const char *delimiter);
+void mmfile_strfreev(char **str_array);
+int mmfile_util_wstrlen(unsigned short *wText);
+short *mmfile_swap_2byte_string(short *mszOutput, short *mszInput, int length);
char *mmfile_get_charset(const char *str);
-char *mmfile_string_convert (const char *str, unsigned int len,
- const char *to_codeset, const char *from_codeset,
- unsigned int *bytes_read,
- unsigned int *bytes_written);
-char *mmfile_strdup (const char *str);
+char *mmfile_string_convert(const char *str, unsigned int len,
+ const char *to_codeset, const char *from_codeset,
+ unsigned int *bytes_read,
+ unsigned int *bytes_written);
+char *mmfile_strdup(const char *str);
-////////////////////////////////////////////////////////////////////////
-// LOCALE API //
-////////////////////////////////////////////////////////////////////////
-char *MMFileUtilGetLocale (int *error);
+/*////////////////////////////////////////////////////////////////////// */
+/* LOCALE API // */
+/*////////////////////////////////////////////////////////////////////// */
+char *MMFileUtilGetLocale(int *error);
-////////////////////////////////////////////////////////////////////////
-// IMAGE API //
-////////////////////////////////////////////////////////////////////////
-typedef enum
-{
- MMFILE_PIXEL_FORMAT_YUV420 = 0,
- MMFILE_PIXEL_FORMAT_YUV422 = 1,
- MMFILE_PIXEL_FORMAT_RGB565 = 2,
- MMFILE_PIXEL_FORMAT_RGB888 = 3,
- MMFILE_PIXEL_FORMAT_MAX,
+/*////////////////////////////////////////////////////////////////////// */
+/* IMAGE API // */
+/*////////////////////////////////////////////////////////////////////// */
+typedef enum {
+ MMFILE_PIXEL_FORMAT_YUV420 = 0,
+ MMFILE_PIXEL_FORMAT_YUV422 = 1,
+ MMFILE_PIXEL_FORMAT_RGB565 = 2,
+ MMFILE_PIXEL_FORMAT_RGB888 = 3,
+ MMFILE_PIXEL_FORMAT_MAX,
} eMMFilePixelFormat;
-int mmfile_util_image_convert (unsigned char *src, eMMFilePixelFormat src_fmt, int src_width, int src_height,
- unsigned char *dst, eMMFilePixelFormat dst_fmt, int dst_width, int dst_height);
+int mmfile_util_image_convert(unsigned char *src, eMMFilePixelFormat src_fmt, int src_width, int src_height,
+ unsigned char *dst, eMMFilePixelFormat dst_fmt, int dst_width, int dst_height);
-////////////////////////////////////////////////////////////////////////
-// MEMORY API //
-////////////////////////////////////////////////////////////////////////
-void *mmfile_malloc (unsigned int size);
+/*////////////////////////////////////////////////////////////////////// */
+/* MEMORY API // */
+/*////////////////////////////////////////////////////////////////////// */
+void *mmfile_malloc(unsigned int size);
#define mmfile_free(ptr) do { if((ptr)) { mmfile_free_r((ptr)); (ptr) = NULL;} } while (0)
-void mmfile_free_r (void *ptr);
+void mmfile_free_r(void *ptr);
void *mmfile_realloc(void *ptr, unsigned int size);
-void *mmfile_memset (void *s, int c, unsigned int n);
-void *mmfile_memcpy (void *dest, const void *src, unsigned int n);
-
-////////////////////////////////////////////////////////////////////////
-// DATA STRUCTURE API //
-////////////////////////////////////////////////////////////////////////
-typedef void* MMFileList;
-MMFileList mmfile_list_alloc ();
-MMFileList mmfile_list_append (MMFileList list, void* data);
-MMFileList mmfile_list_prepend (MMFileList list, void* data);
-MMFileList mmfile_list_find (MMFileList list, void* data);
-MMFileList mmfile_list_first (MMFileList list);
-MMFileList mmfile_list_last (MMFileList list);
-MMFileList mmfile_list_nth (MMFileList list, unsigned int n);
-MMFileList mmfile_list_next (MMFileList list);
-MMFileList mmfile_list_previous (MMFileList list);
-unsigned int mmfile_list_length (MMFileList list);
-MMFileList mmfile_list_remove (MMFileList list, void *data);
-MMFileList mmfile_list_remove_all (MMFileList list, void *data);
-MMFileList mmfile_list_reverse (MMFileList list);
-void mmfile_list_free (MMFileList list);
-
-
-
-////////////////////////////////////////////////////////////////////////
-// MEMORY DEBUG API //
-////////////////////////////////////////////////////////////////////////
+void *mmfile_memset(void *s, int c, unsigned int n);
+void *mmfile_memcpy(void *dest, const void *src, unsigned int n);
+
+/*////////////////////////////////////////////////////////////////////// */
+/* DATA STRUCTURE API // */
+/*////////////////////////////////////////////////////////////////////// */
+typedef void *MMFileList;
+MMFileList mmfile_list_alloc();
+MMFileList mmfile_list_append(MMFileList list, void *data);
+MMFileList mmfile_list_prepend(MMFileList list, void *data);
+MMFileList mmfile_list_find(MMFileList list, void *data);
+MMFileList mmfile_list_first(MMFileList list);
+MMFileList mmfile_list_last(MMFileList list);
+MMFileList mmfile_list_nth(MMFileList list, unsigned int n);
+MMFileList mmfile_list_next(MMFileList list);
+MMFileList mmfile_list_previous(MMFileList list);
+unsigned int mmfile_list_length(MMFileList list);
+MMFileList mmfile_list_remove(MMFileList list, void *data);
+MMFileList mmfile_list_remove_all(MMFileList list, void *data);
+MMFileList mmfile_list_reverse(MMFileList list);
+void mmfile_list_free(MMFileList list);
+
+
+
+/*////////////////////////////////////////////////////////////////////// */
+/* MEMORY DEBUG API // */
+/*////////////////////////////////////////////////////////////////////// */
#ifdef __MMFILE_MEM_TRACE__
-void *mmfile_malloc_debug (unsigned int size, const char *func, unsigned int line);
-void *mmfile_calloc_debug (unsigned int nmemb, unsigned int size, const char *func, unsigned int line);
-void mmfile_free_debug (void *ptr, const char *func, unsigned int line);
-void *mmfile_realloc_debug (void *ptr, unsigned int size, const char *func, unsigned int line);
-void *mmfile_memset_debug (void *s, int c, unsigned int n, const char *func, unsigned int line);
-void *mmfile_memcpy_debug (void *dest, const void *src, unsigned int n, const char *func, unsigned int line);
-
-char *mmfile_string_convert_debug (const char *str, unsigned int len,
- const char *to_codeset, const char *from_codeset,
- int *bytes_read,
- int *bytes_written,
- const char *func,
- unsigned int line);
-char *mmfile_strdup_debug (const char *str, const char *func, unsigned int line);
+void *mmfile_malloc_debug(unsigned int size, const char *func, unsigned int line);
+void *mmfile_calloc_debug(unsigned int nmemb, unsigned int size, const char *func, unsigned int line);
+void mmfile_free_debug(void *ptr, const char *func, unsigned int line);
+void *mmfile_realloc_debug(void *ptr, unsigned int size, const char *func, unsigned int line);
+void *mmfile_memset_debug(void *s, int c, unsigned int n, const char *func, unsigned int line);
+void *mmfile_memcpy_debug(void *dest, const void *src, unsigned int n, const char *func, unsigned int line);
+
+char *mmfile_string_convert_debug(const char *str, unsigned int len,
+ const char *to_codeset, const char *from_codeset,
+ int *bytes_read,
+ int *bytes_written,
+ const char *func,
+ unsigned int line);
+char *mmfile_strdup_debug(const char *str, const char *func, unsigned int line);
#define mmfile_malloc(size) mmfile_malloc_debug((size), __func__, __LINE__)
#define mmfile_calloc(size) mmfile_calloc_debug((size), __func__, __LINE__)
#define mmfile_memset(ptr, c, n) mmfile_memset_debug((ptr), (c), (n), __func__, __LINE__)
#define mmfile_memcpy(dest, src, n) mmfile_memcpy_debug((ptr), (src), (n), __func__, __LINE__)
-#define mmfile_string_convert(str,len,to_codeset,from_codeset,bytes_read,bytes_written) mmfile_string_convert_debug((str),(len),(to_codeset),(from_codeset),(bytes_read),(bytes_written), __func__,__LINE__)
-#define mmfile_strdup(x) mmfile_strdup_debug((x),__func__,__LINE__)
-
+#define mmfile_string_convert(str, len, to_codeset, from_codeset, bytes_read, bytes_written) mmfile_string_convert_debug((str), (len), (to_codeset), (from_codeset), (bytes_read), (bytes_written), __func__, __LINE__)
+#define mmfile_strdup(x) mmfile_strdup_debug((x), __func__, __LINE__)
+
#endif
-////////////////////////////////////////////////////////////////////////
-// TAG API //
-////////////////////////////////////////////////////////////////////////
+/*////////////////////////////////////////////////////////////////////// */
+/* TAG API // */
+/*////////////////////////////////////////////////////////////////////// */
#define MM_FILE_REVERSE_BYTE_ORDER_INT(i) ((int)((((i)&0xFF000000)>>24) | (((i)&0x00FF0000)>>8) | (((i)&0x0000FF00)<<8) | (((i)&0x000000FF)<<24)))
#define MM_FILE_REVERSE_BYTE_ORDER_SHORT(s) ((short)((((s)&0xFF00)>>8) | (((s)&0x00FF)<<8)))
#define _FREE_EX(ptr) { if ((ptr)) {mmfile_free ((ptr)); (ptr) = NULL;} }
#define _STRNCPY_EX(dst,src,size) { if ((size>0)) {strncpy((char*)(dst), (char*)(src),(size)); *((dst) + (size)) = '\0';}}
-inline static int __AvMemstr (unsigned char* mem, unsigned char* str, int str_len, int search_range)
+inline static int __AvMemstr(unsigned char *mem, unsigned char *str, int str_len, int search_range)
{
int offset = 0;
unsigned char *pSrc = mem;
- for (offset = 0; offset < search_range; offset++ )
- {
+ for (offset = 0; offset < search_range; offset++) {
pSrc = mem + offset;
if (memcmp(pSrc, str, str_len) == 0)
return offset;
} AvID3v2PictureType;
-#define MP3TAGINFO_SIZE 128 // file end 128 byte
+#define MP3TAGINFO_SIZE 128 /* file end 128 byte */
#define MP3_ID3_TITLE_LENGTH 30
#define MP3_ID3_ARTIST_LENGTH 30
#define MP3_ID3_ALBUM_LENGTH 30
AV_ID3V2_UTF16_BE,
AV_ID3V2_UTF8,
AV_ID3V2_MAX
-
+
} AvID3v2EncodingType;
-typedef struct{
+typedef struct {
char *pImageBuf;
char *imageDescription;
char imageMIMEType[MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH];
int imgDesLen;
int imgMimetypeLen;
bool bURLInfo;
-
+
} AvTagVer2ImageInfo;
- typedef struct{
+typedef struct {
int tagLen;
char tagVersion;
} AvTagVer2AdditionalData;
-
-typedef struct
-{
+
+typedef struct {
int titleLen;
int artistLen;
int authorLen;
int recdateLen;
int conductorLen;
int album_artistLen;
-
-// for PC Studio Podcast
+
+/* for PC Studio Podcast */
int contentGroupLen;
-
-// for ID3V2 Tag
+
+/* for ID3V2 Tag */
int encbyLen;
int urlLen;
int originartistLen;
int unsynclyricsLen;
int syncLyricsNum;
-// To send resolution info to appl from OEM
- int width;
+/* To send resolution info to appl from OEM */
+ int width;
int height;
-
+
unsigned int bitRate;
unsigned int sampleRate;
unsigned int channels;
-// unsigned long creationTime;
+/* unsigned long creationTime; */
long long duration;
-// for mp3 Info
- char *pToc; // VBR�϶� SeekPosition�� ���ϱ� ���� TOC ���̺��� ������ ��ï¿?�ִ� char ï¿½è¿ , 100 ����Ʈ ����
- unsigned int mpegVersion; // 1 : mpeg 1, 2 : mpeg 2, 3 : mpeg2.5
- unsigned int layer; // 1 : layer1, 2 : layer2, 3 : layer3
- unsigned int channelIndex; // 0 : stereo, 1 : joint_stereo, 2 : dual_channel, 3 : mono
+/* for mp3 Info */
+ char *pToc; /* VBR??? SeekPosition?? ????? ???? TOC ??????? ?????? ??\EF\BF???? char ?ò÷, 100 ????? ???? */
+ unsigned int mpegVersion; /* 1 : mpeg 1, 2 : mpeg 2, 3 : mpeg2.5 */
+ unsigned int layer; /* 1 : layer1, 2 : layer2, 3 : layer3 */
+ unsigned int channelIndex; /* 0 : stereo, 1 : joint_stereo, 2 : dual_channel, 3 : mono */
unsigned int objectType;
unsigned int headerType;
- long long fileLen; // mp3 ������ ��ü ����
- long headerPos; // mp3 �����ó������ ��Ÿ���� ��ġ
- long long datafileLen; // ID3Tag���� �����ϰ� ���� mp3 frame���� ���� , VBR�϶� XHEADDATA �� bytes �� �ش��Ѵ�
- int frameSize; // mp3 frame �� ���� ũ��
- int frameNum; // mp3 ���Ͽ� �������� � ����ִ°�
- bool bVbr; // VBR mp3?
- bool bPadding; // Padding?
+ long long fileLen; /* mp3 ?????? ??u ???? */
+ long headerPos; /* mp3 ????\EF\BF?o?????? ??????? ??? */
+ long long datafileLen; /* ID3Tag???? ??????? ???? mp3 frame???? ????, VBR??? XHEADDATA ?? bytes ?? ?????? */
+ int frameSize; /* mp3 frame ?? ???? ??? */
+ int frameNum; /* mp3 ????? ???????? ?? ?????¡Æ\EF\BF? */
+ bool bVbr; /* VBR mp3? */
+ bool bPadding; /* Padding? */
bool bV1tagFound;
- char *pTitle; //Title/songname/
- char *pArtist; //Lead performer(s)/Soloist(s),
- char *pAuthor; //Author
+ char *pTitle; /*Title/songname/ */
+ char *pArtist; /*Lead performer(s)/Soloist(s), */
+ char *pAuthor; /*Author */
char *pCopyright;
char *pDescription;
char *pComment;
char *pRating;
- char *pAlbum; //Album/Movie/
+ char *pAlbum; /*Album/Movie/ */
char *pAlbum_Artist;
char *pYear;
- char *pGenre;
- char *pTrackNum; //Track number/Position in set
- char *pRecDate; //Recording dates
-
+ char *pGenre;
+ char *pTrackNum; /*Track number/Position in set */
+ char *pRecDate; /*Recording dates */
+
char *pConductor; /*[#TPE3 Conductor/performer refinement], ADDED: 2010-01-xx*/
-
-// for PC Studio Podcast
+
+/* for PC Studio Podcast */
char *pContentGroup;
-// for ID3V2 Tag
- char *pEncBy; //Encoded by
- char *pURL; //User defined URL link frame for ID3V2 Tag
- char *pOriginArtist; //Original artist(s)/performer(s)
- char *pComposer; //Composer
- char *pUnsyncLyrics; //Unsychronised lyrics/text transcription
- GList *pSyncLyrics; //Sychronised lyrics/text
-
- AvTagVer2ImageInfo imageInfo; //Album art attached feature
- AvTagVer2AdditionalData tagV2Info; //Needed data for ID3 tag parsing
-
-// for DRM 2.0
+/* for ID3V2 Tag */
+ char *pEncBy; /*Encoded by */
+ char *pURL; /*User defined URL link frame for ID3V2 Tag */
+ char *pOriginArtist; /*Original artist(s)/performer(s) */
+ char *pComposer; /*Composer */
+ char *pUnsyncLyrics; /*Unsychronised lyrics/text transcription */
+ GList *pSyncLyrics; /*Sychronised lyrics/text */
+
+ AvTagVer2ImageInfo imageInfo; /*Album art attached feature */
+ AvTagVer2AdditionalData tagV2Info; /*Needed data for ID3 tag parsing */
+
+/* for DRM 2.0 */
char *pTransactionID;
-//for ID3V1 Tag
- unsigned char genre;
-
+/*for ID3V1 Tag */
+ unsigned char genre;
+
} AvFileContentInfo;
typedef struct {
typedef struct {
unsigned long time_info;
char *lyric_info;
-}AvSynclyricsInfo;
+} AvSynclyricsInfo;
-void mm_file_free_synclyrics_list(GList * synclyrics_list);
+void mm_file_free_synclyrics_list(GList *synclyrics_list);
-inline static void mm_file_free_AvFileContentInfo (AvFileContentInfo *pInfo)
+inline static void mm_file_free_AvFileContentInfo(AvFileContentInfo *pInfo)
{
if (pInfo) {
- if (pInfo->pToc) mmfile_free (pInfo->pToc);
- if (pInfo->pTitle) mmfile_free (pInfo->pTitle);
- if (pInfo->pArtist) mmfile_free (pInfo->pArtist);
- if (pInfo->pAuthor) mmfile_free (pInfo->pAuthor);
- if (pInfo->pCopyright) mmfile_free (pInfo->pCopyright);
- if (pInfo->pDescription) mmfile_free (pInfo->pDescription);
- if (pInfo->pComment) mmfile_free (pInfo->pComment);
- if (pInfo->pRating) mmfile_free (pInfo->pRating);
- if (pInfo->pAlbum) mmfile_free (pInfo->pAlbum);
- if (pInfo->pAlbum_Artist) mmfile_free (pInfo->pAlbum_Artist);
- if (pInfo->pYear) mmfile_free (pInfo->pYear);
- if (pInfo->pGenre) mmfile_free (pInfo->pGenre);
- if (pInfo->pTrackNum) mmfile_free (pInfo->pTrackNum);
- if (pInfo->pRecDate) mmfile_free (pInfo->pRecDate);
- if (pInfo->pConductor) mmfile_free (pInfo->pConductor);
- if (pInfo->pContentGroup) mmfile_free (pInfo->pContentGroup);
- if (pInfo->pEncBy) mmfile_free (pInfo->pEncBy);
- if (pInfo->pURL) mmfile_free (pInfo->pURL);
- if (pInfo->pOriginArtist) mmfile_free (pInfo->pOriginArtist);
- if (pInfo->pComposer) mmfile_free (pInfo->pComposer);
- if (pInfo->pUnsyncLyrics) mmfile_free (pInfo->pUnsyncLyrics);
- if (pInfo->imageInfo.pImageBuf) mmfile_free (pInfo->imageInfo.pImageBuf);
- if (pInfo->imageInfo.imageDescription) mmfile_free (pInfo->imageInfo.imageDescription);
- if (strlen(pInfo->imageInfo.imageMIMEType)>0) memset(pInfo->imageInfo.imageMIMEType, 0, MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH);
- if (pInfo->pTransactionID) mmfile_free (pInfo->pTransactionID);
+ if (pInfo->pToc) mmfile_free(pInfo->pToc);
+ if (pInfo->pTitle) mmfile_free(pInfo->pTitle);
+ if (pInfo->pArtist) mmfile_free(pInfo->pArtist);
+ if (pInfo->pAuthor) mmfile_free(pInfo->pAuthor);
+ if (pInfo->pCopyright) mmfile_free(pInfo->pCopyright);
+ if (pInfo->pDescription) mmfile_free(pInfo->pDescription);
+ if (pInfo->pComment) mmfile_free(pInfo->pComment);
+ if (pInfo->pRating) mmfile_free(pInfo->pRating);
+ if (pInfo->pAlbum) mmfile_free(pInfo->pAlbum);
+ if (pInfo->pAlbum_Artist) mmfile_free(pInfo->pAlbum_Artist);
+ if (pInfo->pYear) mmfile_free(pInfo->pYear);
+ if (pInfo->pGenre) mmfile_free(pInfo->pGenre);
+ if (pInfo->pTrackNum) mmfile_free(pInfo->pTrackNum);
+ if (pInfo->pRecDate) mmfile_free(pInfo->pRecDate);
+ if (pInfo->pConductor) mmfile_free(pInfo->pConductor);
+ if (pInfo->pContentGroup) mmfile_free(pInfo->pContentGroup);
+ if (pInfo->pEncBy) mmfile_free(pInfo->pEncBy);
+ if (pInfo->pURL) mmfile_free(pInfo->pURL);
+ if (pInfo->pOriginArtist) mmfile_free(pInfo->pOriginArtist);
+ if (pInfo->pComposer) mmfile_free(pInfo->pComposer);
+ if (pInfo->pUnsyncLyrics) mmfile_free(pInfo->pUnsyncLyrics);
+ if (pInfo->imageInfo.pImageBuf) mmfile_free(pInfo->imageInfo.pImageBuf);
+ if (pInfo->imageInfo.imageDescription) mmfile_free(pInfo->imageInfo.imageDescription);
+ if (strlen(pInfo->imageInfo.imageMIMEType) > 0) memset(pInfo->imageInfo.imageMIMEType, 0, MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH);
+ if (pInfo->pTransactionID) mmfile_free(pInfo->pTransactionID);
}
}
-bool mm_file_id3tag_parse_v110 (AvFileContentInfo* pInfo, unsigned char *buffer); //20050401 Condol : for MP3 content Info.
-bool mm_file_id3tag_parse_v222 (AvFileContentInfo* pInfo, unsigned char *buffer);
-bool mm_file_id3tag_parse_v223 (AvFileContentInfo* pInfo, unsigned char *buffer);
-bool mm_file_id3tag_parse_v224 (AvFileContentInfo* pInfo, unsigned char *buffer);
-void mm_file_id3tag_restore_content_info (AvFileContentInfo* pInfo);
-int MMFileUtilGetMetaDataFromMP4 (MMFileFormatContext *formatContext);
+bool mm_file_id3tag_parse_v110(AvFileContentInfo *pInfo, unsigned char *buffer); /*20050401 Condol : for MP3 content Info. */
+bool mm_file_id3tag_parse_v222(AvFileContentInfo *pInfo, unsigned char *buffer);
+bool mm_file_id3tag_parse_v223(AvFileContentInfo *pInfo, unsigned char *buffer);
+bool mm_file_id3tag_parse_v224(AvFileContentInfo *pInfo, unsigned char *buffer);
+void mm_file_id3tag_restore_content_info(AvFileContentInfo *pInfo);
+int MMFileUtilGetMetaDataFromMP4(MMFileFormatContext *formatContext);
#ifdef __cplusplus
static unsigned char is_little_endian = 0;
-inline static int _is_little_endian (void)
+inline static int _is_little_endian(void)
{
int i = 0x00000001;
return ((char *)&i)[0];
}
EXPORT_API
-inline unsigned int mmfile_io_be_uint32 (unsigned int value)
+inline unsigned int mmfile_io_be_uint32(unsigned int value)
{
- return (is_little_endian == 0) ? value : ((unsigned int)((((value)&0xFF000000)>>24) | (((value)&0x00FF0000)>>8) | (((value)&0x0000FF00)<<8) | (((value)&0x000000FF)<<24)));
+ return (is_little_endian == 0) ? value : ((unsigned int)((((value) & 0xFF000000) >> 24) | (((value) & 0x00FF0000) >> 8) | (((value) & 0x0000FF00) << 8) | (((value) & 0x000000FF) << 24)));
}
EXPORT_API
-inline unsigned int mmfile_io_le_uint32 (unsigned int value)
+inline unsigned int mmfile_io_le_uint32(unsigned int value)
{
- return (is_little_endian == 1) ? value : ((unsigned int)((((value)&0xFF000000)>>24) | (((value)&0x00FF0000)>>8) | (((value)&0x0000FF00)<<8) | (((value)&0x000000FF)<<24)));
+ return (is_little_endian == 1) ? value : ((unsigned int)((((value) & 0xFF000000) >> 24) | (((value) & 0x00FF0000) >> 8) | (((value) & 0x0000FF00) << 8) | (((value) & 0x000000FF) << 24)));
}
EXPORT_API
-inline int mmfile_io_be_int32 (unsigned int value)
+inline int mmfile_io_be_int32(unsigned int value)
{
- return (is_little_endian == 0) ? value : ((int)((((value)&0xFF000000)>>24) | (((value)&0x00FF0000)>>8) | (((value)&0x0000FF00)<<8) | (((value)&0x000000FF)<<24)));
+ return (is_little_endian == 0) ? value : ((unsigned int)((((value) & 0xFF000000) >> 24) | (((value) & 0x00FF0000) >> 8) | (((value) & 0x0000FF00) << 8) | (((value) & 0x000000FF) << 24)));
}
EXPORT_API
-inline int mmfile_io_le_int32 (unsigned int value)
+inline int mmfile_io_le_int32(unsigned int value)
{
- return (is_little_endian == 1) ? value : ((int)((((value)&0xFF000000)>>24) | (((value)&0x00FF0000)>>8) | (((value)&0x0000FF00)<<8) | (((value)&0x000000FF)<<24)));
+ return (is_little_endian == 1) ? value : ((unsigned int)((((value) & 0xFF000000) >> 24) | (((value) & 0x00FF0000) >> 8) | (((value) & 0x0000FF00) << 8) | (((value) & 0x000000FF) << 24)));
}
EXPORT_API
-inline unsigned short mmfile_io_be_uint16 (unsigned short value)
+inline unsigned short mmfile_io_be_uint16(unsigned short value)
{
- return (is_little_endian == 0) ? value : ((unsigned short)((((value)&0xFF00)>>8) | (((value)&0x00FF)<<8)));
+ return (is_little_endian == 0) ? value : ((unsigned short)((((value) & 0xFF00) >> 8) | (((value) & 0x00FF) << 8)));
}
EXPORT_API
-inline unsigned short mmfile_io_le_uint16 (unsigned short value)
+inline unsigned short mmfile_io_le_uint16(unsigned short value)
{
- return (is_little_endian == 1) ? value : ((unsigned short)((((value)&0xFF00)>>8) | (((value)&0x00FF)<<8)));
+ return (is_little_endian == 1) ? value : ((unsigned short)((((value) & 0xFF00) >> 8) | (((value) & 0x00FF) << 8)));
}
EXPORT_API
-inline short mmfile_io_be_int16 (unsigned short value)
+inline short mmfile_io_be_int16(unsigned short value)
{
- return (is_little_endian == 0) ? value : ((short)((((value)&0xFF00)>>8) | (((value)&0x00FF)<<8)));
+ return (is_little_endian == 0) ? value : ((short)((((value) & 0xFF00) >> 8) | (((value) & 0x00FF) << 8)));
}
EXPORT_API
-inline short mmfile_io_le_int16 (unsigned short value)
+inline short mmfile_io_le_int16(unsigned short value)
{
- return (is_little_endian == 1) ? value : ((short)((((value)&0xFF00)>>8) | (((value)&0x00FF)<<8)));
+ return (is_little_endian == 1) ? value : ((short)((((value) & 0xFF00) >> 8) | (((value) & 0x00FF) << 8)));
}
int fileNameLen = 0;
if (!handle || !Func || !filename || !Func->mmfile_open) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
err = MMFILE_IO_FAILED;
goto fail;
}
- pHandle = mmfile_malloc (sizeof(MMFileIOHandle));
+ pHandle = mmfile_malloc(sizeof(MMFileIOHandle));
if (!pHandle) {
- debug_error ("mmfile_malloc: pHandle\n");
+ debug_error("mmfile_malloc: pHandle\n");
err = MMFILE_IO_FAILED;
goto fail;
}
pHandle->flags = flags;
pHandle->privateData = NULL;
fileNameLen = strlen(filename);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("[%d, %s]\n", fileNameLen, filename);
- #endif
- pHandle->fileName = mmfile_malloc (fileNameLen + 1);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("[%d, %s]\n", fileNameLen, filename);
+#endif
+ pHandle->fileName = mmfile_malloc(fileNameLen + 1);
if (!pHandle->fileName) {
- debug_error ("mmfile_malloc: pHandle->fileName\n");
+ debug_error("mmfile_malloc: pHandle->fileName\n");
err = MMFILE_IO_FAILED;
goto fail;
}
memcpy(pHandle->fileName, filename, fileNameLen);
- err = Func->mmfile_open (pHandle, filename, flags);
+ err = Func->mmfile_open(pHandle, filename, flags);
if (err < 0) {
- debug_error ("mmfile_open: pHandle->fileName\n");
+ debug_error("mmfile_open: pHandle->fileName\n");
err = MMFILE_IO_FAILED;
goto fail;
}
-
+
return MMFILE_IO_SUCCESS;
fail:
- if (handle && *handle) // fix for prevent
- {
+ if (handle && *handle) { /* fix for prevent */
mmfile_close(*handle);
*handle = NULL;
}
-
+
return err;
}
{
MMFileIOFunc *pFuc = NULL;
const char *pFile = NULL;
- char handle_str[256] = {0,};
+ char handle_str[256] = {0, };
char *pHandleName = NULL;
if (!handle || !filename) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_IO_FAILED;
}
- memset (handle_str, 0x00, sizeof(handle_str));
+ memset(handle_str, 0x00, sizeof(handle_str));
pFile = filename;
pHandleName = handle_str;
goto file_handle;
}
- if ((pHandleName - handle_str) < sizeof(handle_str) - 1) {
+ if ((pHandleName - handle_str) < (int)sizeof(handle_str) - 1) {
*pHandleName++ = *pFile;
}
pFile++;
while (pFuc != NULL) {
if (!strcmp(handle_str, pFuc->handleName)) {
- return _mmfile_open (handle, pFuc, filename, flags);
+ return _mmfile_open(handle, pFuc, filename, flags);
}
pFuc = pFuc->next;
}
return MMFILE_IO_FAILED;
}
- ret = handle->iofunc->mmfile_read (handle, buf, size);
+ ret = handle->iofunc->mmfile_read(handle, buf, size);
return ret;
}
return MMFILE_IO_FAILED;
}
- ret = handle->iofunc->mmfile_write (handle, buf, size);
+ ret = handle->iofunc->mmfile_write(handle, buf, size);
return ret;
}
}
EXPORT_API
-int mmfile_register_io_func (MMFileIOFunc *iofunc)
+int mmfile_register_io_func(MMFileIOFunc *iofunc)
{
MMFileIOFunc **ptr = NULL;
}
EXPORT_API
-int mmfile_register_io_all ()
+int mmfile_register_io_all()
{
static int initialized = 0;
return MMFILE_IO_FAILED;
}
- is_little_endian = _is_little_endian ();
+ is_little_endian = _is_little_endian();
initialized = 1;
extern MMFileIOFunc mmfile_file_io_handler;
extern MMFileIOFunc mmfile_mem_io_handler;
extern MMFileIOFunc mmfile_mmap_io_handler;
- mmfile_register_io_func (&mmfile_file_io_handler);
+ mmfile_register_io_func(&mmfile_file_io_handler);
#ifdef DRM_SUPPORT
- mmfile_register_io_func (&mmfile_drm_io_handler);
+ mmfile_register_io_func(&mmfile_drm_io_handler);
#endif
- mmfile_register_io_func (&mmfile_mem_io_handler);
- mmfile_register_io_func (&mmfile_mmap_io_handler);
+ mmfile_register_io_func(&mmfile_mem_io_handler);
+ mmfile_register_io_func(&mmfile_mmap_io_handler);
return MMFILE_IO_SUCCESS;
}
* limitations under the License.
*
*/
-
+
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include "mm_file_debug.h"
#include "mm_file_utils.h"
-typedef struct
-{
- DRM_DECRYPT_HANDLE hfile;
- long long offset;
- long long fsize;
+typedef struct {
+ DRM_DECRYPT_HANDLE hfile;
+ long long offset;
+ long long fsize;
} MMFileDRMHandle;
drm_trusted_set_consumption_state_info_s state_input_data;
int ret = 0;
- if (!h || !pseudofilename || !h->iofunc || !h->iofunc->handleName)
- {
- debug_error ("invalid param\n");
+ if (!h || !pseudofilename || !h->iofunc || !h->iofunc->handleName) {
+ debug_error("invalid param\n");
return MMFILE_IO_FAILED;
}
pseudofilename += strlen(h->iofunc->handleName) + 3; /* :// */
/* Check is DRM */
- ret = drm_is_drm_file (pseudofilename, &res);
- if (DRM_FALSE == res)
- {
- debug_error ("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
+ ret = drm_is_drm_file(pseudofilename, &res);
+ if (DRM_FALSE == res) {
+ debug_error("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
return MMFILE_IO_FAILED;
}
- if(ret != DRM_RETURN_SUCCESS)
- {
- debug_error ("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
+ if (ret != DRM_RETURN_SUCCESS) {
+ debug_error("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
return MMFILE_IO_FAILED;
}
/* Checks the DRM file type (supports only for OMA) if it is DRM */
ret = drm_get_file_type(pseudofilename, &file_type);
- if(ret != DRM_RETURN_SUCCESS)
- {
- debug_error ("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
+ if (ret != DRM_RETURN_SUCCESS) {
+ debug_error("error: %s is not DRM file. ret[%x]\n", pseudofilename, ret);
return MMFILE_IO_FAILED;
}
- if((file_type != DRM_TYPE_OMA_V1) && (file_type != DRM_TYPE_OMA_V2))
- {
- debug_error ("error: %s is not DRM file. file_type[%d]\n", pseudofilename, file_type);
+ if ((file_type != DRM_TYPE_OMA_V1) && (file_type != DRM_TYPE_OMA_V2)) {
+ debug_error("error: %s is not DRM file. file_type[%d]\n", pseudofilename, file_type);
return MMFILE_IO_FAILED;
}
/* Set DRM handle*/
- drmHandle = mmfile_malloc (sizeof(MMFileDRMHandle));
- if (NULL == drmHandle)
- {
- debug_error ("error: mmfile_malloc\n");
+ drmHandle = mmfile_malloc(sizeof(MMFileDRMHandle));
+ if (NULL == drmHandle) {
+ debug_error("error: mmfile_malloc\n");
return MMFILE_IO_FAILED;
}
memset(&open_output_data, 0x0, sizeof(drm_trusted_open_decrypt_resp_data_s));
memcpy(open_input_data.filePath, pseudofilename, strlen(pseudofilename));
- if(file_type == DRM_TYPE_OMA_V1) open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;
+ if (file_type == DRM_TYPE_OMA_V1) open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V1;
else open_input_data.file_type = DRM_TRUSTED_TYPE_OMA_V2;
open_input_data.permission = DRM_TRUSTED_PERMISSION_TYPE_DISPLAY;
- //open_input_data.operation_callback.callback;
+ /*open_input_data.operation_callback.callback; */
- ret = drm_trusted_open_decrypt_session(&open_input_data,&open_output_data, &drmHandle->hfile);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_open_decrypt_session() [%x]\n", ret);
+ ret = drm_trusted_open_decrypt_session(&open_input_data, &open_output_data, &drmHandle->hfile);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_open_decrypt_session() [%x]\n", ret);
ret = MMFILE_IO_FAILED;
goto exception;
}
seek_input_data.seek_mode = DRM_SEEK_END; /* Set cursor to end */
ret = drm_trusted_seek_decrypt_session(drmHandle->hfile, &seek_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
ret = MMFILE_IO_FAILED;
goto exception;
}
/* Tell to get the file size */
memset(&tell_output_data, 0x0, sizeof(drm_trusted_tell_decrypt_resp_data_s));
ret = drm_trusted_tell_decrypt_session(drmHandle->hfile, &tell_output_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_tell_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_tell_decrypt_session() [%x]\n", ret);
ret = MMFILE_IO_FAILED;
goto exception;
}
seek_input_data.offset = 0;
seek_input_data.seek_mode = DRM_SEEK_SET;
ret = drm_trusted_seek_decrypt_session(drmHandle->hfile, &seek_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_seek_decrypt_session() [%x]\n", ret);
ret = MMFILE_IO_FAILED;
goto exception;
}
memset(&state_input_data, 0x0, sizeof(drm_trusted_set_consumption_state_info_s));
state_input_data.state = DRM_CONSUMPTION_PREVIEW;
ret = drm_trusted_set_decrypt_state(drmHandle->hfile, &state_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_set_decrypt_state [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_set_decrypt_state [%x]\n", ret);
ret = MMFILE_IO_FAILED;
goto exception;
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("drm open success===============\n");
+ debug_msg("drm open success===============\n");
#endif
return MMFILE_IO_SUCCESS;
exception:
- if (drmHandle)
- {
- if (drmHandle->hfile)
- {
- drm_trusted_close_decrypt_session(&drmHandle->hfile);
+ if (drmHandle) {
+ if (drmHandle->hfile) {
+ drm_trusted_close_decrypt_session(&drmHandle->hfile);
}
mmfile_free(drmHandle);
static int mmfile_drm_read(MMFileIOHandle *h, unsigned char *buf, int size)
{
- MMFileDRMHandle *drmHandle =NULL;
+ MMFileDRMHandle *drmHandle = NULL;
drm_trusted_payload_info_s read_input_data;
drm_trusted_read_decrypt_resp_data_s read_output_data;
int ret = 0;
- if (!h || !h->privateData || !buf)
- {
- debug_error ("invalid param\n");
+ if (!h || !h->privateData || !buf) {
+ debug_error("invalid param\n");
return MMFILE_IO_FAILED;
}
drmHandle = h->privateData;
- memset(&read_input_data,0x0,sizeof(drm_trusted_payload_info_s));
- memset(&read_output_data,0x0,sizeof(drm_trusted_read_decrypt_resp_data_s));
+ memset(&read_input_data, 0x0, sizeof(drm_trusted_payload_info_s));
+ memset(&read_output_data, 0x0, sizeof(drm_trusted_read_decrypt_resp_data_s));
read_input_data.payload_data = buf;
read_input_data.payload_data_len = (unsigned int)size;
read_input_data.payload_data_output = buf;
ret = drm_trusted_read_decrypt_session(drmHandle->hfile, &read_input_data, &read_output_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_read_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_read_decrypt_session() [%x]\n", ret);
return MMFILE_IO_FAILED;
}
int ret = 0;
if (!h || !h->privateData) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_IO_FAILED;
}
drm_whence = DRM_SEEK_END;
break;
default:
- debug_error ("invalid whence[%d]\n", whence);
+ debug_error("invalid whence[%d]\n", whence);
return MMFILE_IO_FAILED;
}
seek_input_data.seek_mode = drm_whence;
ret = drm_trusted_seek_decrypt_session(drmHandle->hfile, &seek_input_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_seek_decrypt_session() [%x] [mode=%d]\n", ret, drm_whence);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_seek_decrypt_session() [%x] [mode=%d]\n", ret, drm_whence);
return MMFILE_IO_FAILED;
}
switch (drm_whence) {
case DRM_SEEK_SET: {
- drmHandle->offset = pos;
- break;
- }
+ drmHandle->offset = pos;
+ break;
+ }
case DRM_SEEK_CUR: {
- drmHandle->offset += pos;
- break;
- }
+ drmHandle->offset += pos;
+ break;
+ }
case DRM_SEEK_END: {
- drmHandle->offset = drmHandle->fsize + pos;
- break;
- }
+ drmHandle->offset = drmHandle->fsize + pos;
+ break;
+ }
}
if (drmHandle->offset > drmHandle->fsize) {
return drmHandle->offset;
}
-static long long mmfile_drm_tell (MMFileIOHandle *h)
+static long long mmfile_drm_tell(MMFileIOHandle *h)
{
MMFileDRMHandle *drmHandle = NULL;
drm_trusted_tell_decrypt_resp_data_s tell_output_data;
int ret = 0;
- if (!h || !h->privateData)
- {
- debug_error ("invalid param\n");
+ if (!h || !h->privateData) {
+ debug_error("invalid param\n");
return MMFILE_IO_FAILED;
}
memset(&tell_output_data, 0x0, sizeof(drm_trusted_tell_decrypt_resp_data_s));
ret = drm_trusted_tell_decrypt_session(drmHandle->hfile, &tell_output_data);
- if (ret != DRM_TRUSTED_RETURN_SUCCESS)
- {
- debug_error ("error: drm_trusted_tell_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_tell_decrypt_session() [%x]\n", ret);
return MMFILE_IO_FAILED;
}
return drmHandle->offset;
}
-static int mmfile_drm_close(MMFileIOHandle* h)
+static int mmfile_drm_close(MMFileIOHandle *h)
{
MMFileDRMHandle *drmHandle = NULL;
drm_trusted_set_consumption_state_info_s state_input_data;
int ret = 0;
- if (!h || !h->privateData)
- {
- debug_error ("invalid param\n");
+ if (!h || !h->privateData) {
+ debug_error("invalid param\n");
return MMFILE_IO_FAILED;
}
drmHandle = h->privateData;
/* Set Consumption state*/
- memset(&state_input_data,0x0,sizeof(drm_trusted_set_consumption_state_info_s));
+ memset(&state_input_data, 0x0, sizeof(drm_trusted_set_consumption_state_info_s));
state_input_data.state = DRM_CONSUMPTION_STOPPED;
ret = drm_trusted_set_decrypt_state(drmHandle->hfile, &state_input_data);
- if(ret != DRM_TRUSTED_RETURN_SUCCESS) {
- debug_error ("error: drm_trusted_set_decrypt_state() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_set_decrypt_state() [%x]\n", ret);
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Success : drm_trusted_set_decrypt_state\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Success : drm_trusted_set_decrypt_state\n");
+#endif
}
- if (drmHandle)
- {
- if (drmHandle->hfile)
- {
+ if (drmHandle) {
+ if (drmHandle->hfile) {
ret = drm_trusted_close_decrypt_session(&drmHandle->hfile);
- if(ret != DRM_TRUSTED_RETURN_SUCCESS) {
- debug_error ("error: drm_trusted_close_decrypt_session() [%x]\n", ret);
+ if (ret != DRM_TRUSTED_RETURN_SUCCESS) {
+ debug_error("error: drm_trusted_close_decrypt_session() [%x]\n", ret);
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Success : drm_trusted_close_decrypt_session\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Success : drm_trusted_close_decrypt_session\n");
+#endif
}
drmHandle->hfile = NULL;
}
- mmfile_free (drmHandle);
+ mmfile_free(drmHandle);
h->privateData = NULL;
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("drm close success===============\n");
+ debug_msg("drm close success===============\n");
#endif
return MMFILE_IO_SUCCESS;
#include "mm_file_debug.h"
#include "mm_file_utils.h"
-typedef struct mmfileiodata
-{
- int fd;
- long long offset;
+typedef struct mmfileiodata {
+ int fd;
+ long long offset;
} tMMFORMAT_FILEIO_DATA;
static int file_open(MMFileIOHandle *handle, const char *filename, int flags)
{
- tMMFORMAT_FILEIO_DATA *privateData = NULL;
- int access = 0;
- int fd = 0;
-
- if (!handle || !filename)
- {
- debug_error ("invalid param\n");
- return MMFILE_IO_FAILED;
- }
-
- filename += strlen(handle->iofunc->handleName) + 3; /* :// */
-
- if (flags & MMFILE_RDWR)
- {
- access = O_CREAT | O_TRUNC | O_RDWR;
- }
- else if (flags & MMFILE_WRONLY)
- {
- access = O_CREAT | O_TRUNC | O_WRONLY;
- }
- else
- {
- access = O_RDONLY;
- }
+ tMMFORMAT_FILEIO_DATA *privateData = NULL;
+ int access = 0;
+ int fd = 0;
+
+ if (!handle || !filename) {
+ debug_error("invalid param\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ filename += strlen(handle->iofunc->handleName) + 3; /* :// */
+
+ if (flags & MMFILE_RDWR) {
+ access = O_CREAT | O_TRUNC | O_RDWR;
+ } else if (flags & MMFILE_WRONLY) {
+ access = O_CREAT | O_TRUNC | O_WRONLY;
+ } else {
+ access = O_RDONLY;
+ }
#ifdef O_BINARY
- access |= O_BINARY;
+ access |= O_BINARY;
#endif
fd = open(filename, access, 0666);
- if (fd < 0)
- {
- debug_error ("open error\n");
+ if (fd < 0) {
+ debug_error("open error\n");
return MMFILE_IO_FAILED;
}
- privateData = mmfile_malloc (sizeof(tMMFORMAT_FILEIO_DATA));
- if (!privateData)
- {
+ privateData = mmfile_malloc(sizeof(tMMFORMAT_FILEIO_DATA));
+ if (!privateData) {
close(fd);
- debug_error ("calloc privateData\n");
+ debug_error("calloc privateData\n");
return MMFILE_IO_FAILED;
}
- privateData->fd = fd;
- privateData->offset = 0;
-
- handle->privateData = (void *)privateData;
- return MMFILE_IO_SUCCESS;
+ privateData->fd = fd;
+ privateData->offset = 0;
+
+ handle->privateData = (void *)privateData;
+ return MMFILE_IO_SUCCESS;
}
static int file_read(MMFileIOHandle *handle, unsigned char *buf, int size)
{
- tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
- int readSize = 0;
-
- readSize = read(privateData->fd, buf, size);
- if (readSize < 0)
- {
- debug_error ("read\n");
- return MMFILE_IO_FAILED;
- }
-
- privateData->offset += readSize;
-
- return readSize;
+ tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
+ int readSize = 0;
+
+ readSize = read(privateData->fd, buf, size);
+ if (readSize < 0) {
+ debug_error("read\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ privateData->offset += readSize;
+
+ return readSize;
}
static int file_write(MMFileIOHandle *handle, unsigned char *buf, int size)
{
- tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
- int writtenSize = 0;
-
- writtenSize = write(privateData->fd, buf, size);
- if (writtenSize < 0)
- {
- debug_error ("write\n");
- return MMFILE_IO_FAILED;
- }
-
- privateData->offset += writtenSize;
-
- return writtenSize;
+ tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
+ int writtenSize = 0;
+
+ writtenSize = write(privateData->fd, buf, size);
+ if (writtenSize < 0) {
+ debug_error("write\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ privateData->offset += writtenSize;
+
+ return writtenSize;
}
static long long file_seek(MMFileIOHandle *handle, long long pos, int whence)
{
- tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
- privateData->offset = lseek(privateData->fd, pos, whence);
- return privateData->offset;
+ tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
+ privateData->offset = lseek(privateData->fd, pos, whence);
+ return privateData->offset;
}
static long long file_tell(MMFileIOHandle *handle)
{
- tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
-
- return privateData->offset;
+ tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
+
+ return privateData->offset;
}
static int file_close(MMFileIOHandle *handle)
{
- tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
- int ret = 0;
-
- if (privateData)
- {
- ret = close(privateData->fd);
- mmfile_free (privateData);
- handle->privateData = NULL;
- return MMFILE_IO_SUCCESS;
- }
-
- return MMFILE_IO_FAILED;
+ tMMFORMAT_FILEIO_DATA *privateData = handle->privateData;
+ /*int ret = 0;*/
+
+ if (privateData) {
+ /*ret = */close(privateData->fd);
+ mmfile_free(privateData);
+ handle->privateData = NULL;
+ return MMFILE_IO_SUCCESS;
+ }
+
+ return MMFILE_IO_FAILED;
}
MMFileIOFunc mmfile_file_io_handler = {
- "file",
- file_open,
- file_read,
- file_write,
- file_seek,
- file_tell,
- file_close,
+ "file",
+ file_open,
+ file_read,
+ file_write,
+ file_seek,
+ file_tell,
+ file_close,
+ NULL
};
int state;
} MMFmemIOHandle;
-static int mmf_mem_open (MMFileIOHandle *handle, const char *filename, int flags)
+static int mmf_mem_open(MMFileIOHandle *handle, const char *filename, int flags)
{
- MMFmemIOHandle *memHandle = NULL;
- char **splitedString = NULL;
-
- if (!handle || !filename || !handle->iofunc || !handle->iofunc->handleName)
- {
- debug_error ("invalid param\n");
- return MMFILE_IO_FAILED;
- }
-
- filename += strlen(handle->iofunc->handleName) + 3; /* ://%d:%d means (memory addr:mem size)*/
-
- splitedString = mmfile_strsplit (filename, ":");
- if (splitedString == NULL)
- {
- debug_error ("invalid param\n");
- return MMFILE_IO_FAILED;
- }
-
- if (!splitedString[0] || !splitedString[1])
- {
- debug_error ("invalid param\n");
- goto exception;
- }
-
- memHandle = mmfile_malloc (sizeof(MMFmemIOHandle));
- if (!memHandle)
- {
- debug_error ("error: mmfile_malloc memHandle\n");
- goto exception;
- }
-
- memHandle->ptr = (unsigned char*)atoll(splitedString[0]); //memory allocation address changed. memHandle->ptr = (unsigned char*)atoi(splitedString[0]);
- memHandle->size = atoi(splitedString[1]);
- memHandle->offset = 0;
- memHandle->state = 0;
-
- handle->privateData = (void*) memHandle;
-
- if (splitedString)
- {
- mmfile_strfreev (splitedString);
- }
-
- return MMFILE_IO_SUCCESS;
+ MMFmemIOHandle *memHandle = NULL;
+ char **splitedString = NULL;
+
+ if (!handle || !filename || !handle->iofunc || !handle->iofunc->handleName) {
+ debug_error("invalid param\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ filename += strlen(handle->iofunc->handleName) + 3; /* ://%d:%d means (memory addr:mem size)*/
+
+ splitedString = mmfile_strsplit(filename, ":");
+ if (splitedString == NULL) {
+ debug_error("invalid param\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ if (!splitedString[0] || !splitedString[1]) {
+ debug_error("invalid param\n");
+ goto exception;
+ }
+
+ memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
+ if (!memHandle) {
+ debug_error("error: mmfile_malloc memHandle\n");
+ goto exception;
+ }
+
+ memHandle->ptr = (unsigned char *)atoll(splitedString[0]); /*memory allocation address changed. memHandle->ptr = (unsigned char*)atoi(splitedString[0]); */
+ memHandle->size = atoi(splitedString[1]);
+ memHandle->offset = 0;
+ memHandle->state = 0;
+
+ handle->privateData = (void *) memHandle;
+
+ if (splitedString) {
+ mmfile_strfreev(splitedString);
+ }
+
+ return MMFILE_IO_SUCCESS;
exception:
- if (splitedString)
- {
- mmfile_strfreev (splitedString);
- }
-
-#if 0 //dead code
- if (memHandle)
- {
- mmfile_free (memHandle);
- handle->privateData = NULL;
- }
+ if (splitedString) {
+ mmfile_strfreev(splitedString);
+ }
+
+#if 0 /*dead code */
+ if (memHandle) {
+ mmfile_free(memHandle);
+ handle->privateData = NULL;
+ }
#endif
- return MMFILE_IO_FAILED;
+ return MMFILE_IO_FAILED;
}
-static int mmf_mem_read (MMFileIOHandle *h, unsigned char *buf, int size)
+static int mmf_mem_read(MMFileIOHandle *h, unsigned char *buf, int size)
{
- MMFmemIOHandle *memHandle = NULL;
- const unsigned char *c = NULL;
- int len = 0;
-
- if (!h || !h->privateData || !buf)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- memHandle = h->privateData;
-
- if (!memHandle->ptr)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- c = memHandle->ptr + memHandle->offset;
-
- if (memHandle->state != EOF)
- {
- len = size;
- if (len + memHandle->offset > memHandle->size)
- {
- len = memHandle->size - memHandle->offset;
- }
- }
-
- memcpy (buf, c, len);
-
- memHandle->offset += len;
-
- if ( memHandle->offset == memHandle->size)
- {
- memHandle->state = EOF;
- }
-
- return len;
+ MMFmemIOHandle *memHandle = NULL;
+ const unsigned char *c = NULL;
+ int len = 0;
+
+ if (!h || !h->privateData || !buf) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ memHandle = h->privateData;
+
+ if (!memHandle->ptr) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ c = memHandle->ptr + memHandle->offset;
+
+ if (memHandle->state != EOF) {
+ len = size;
+ if (len + memHandle->offset > memHandle->size) {
+ len = memHandle->size - memHandle->offset;
+ }
+ }
+
+ memcpy(buf, c, len);
+
+ memHandle->offset += len;
+
+ if (memHandle->offset == memHandle->size) {
+ memHandle->state = EOF;
+ }
+
+ return len;
}
-static int mmf_mem_write (MMFileIOHandle *h, unsigned char *buf, int size)
+static int mmf_mem_write(MMFileIOHandle *h, unsigned char *buf, int size)
{
- MMFmemIOHandle *memHandle = NULL;
- unsigned char *c = NULL;
- int len = 0;
-
- if (!h || !h->privateData || !buf)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- memHandle = h->privateData;
-
- c = memHandle->ptr + memHandle->offset;
-
- if (memHandle->state != EOF)
- {
- len = size;
- if (len + memHandle->offset > memHandle->size)
- {
- len = memHandle->size - memHandle->offset;
- }
- }
-
- memcpy (c, buf, len);
-
- memHandle->offset += len;
-
- if ( memHandle->offset == memHandle->size)
- {
- memHandle->state = EOF;
- }
-
- return len;
+ MMFmemIOHandle *memHandle = NULL;
+ unsigned char *c = NULL;
+ int len = 0;
+
+ if (!h || !h->privateData || !buf) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ memHandle = h->privateData;
+
+ c = memHandle->ptr + memHandle->offset;
+
+ if (memHandle->state != EOF) {
+ len = size;
+ if (len + memHandle->offset > memHandle->size) {
+ len = memHandle->size - memHandle->offset;
+ }
+ }
+
+ memcpy(c, buf, len);
+
+ memHandle->offset += len;
+
+ if (memHandle->offset == memHandle->size) {
+ memHandle->state = EOF;
+ }
+
+ return len;
}
-static long long mmf_mem_seek (MMFileIOHandle *h, long long pos, int whence)
+static long long mmf_mem_seek(MMFileIOHandle *h, long long pos, int whence)
{
- MMFmemIOHandle *memHandle = NULL;
- long tmp_offset = 0;
-
- if (!h || !h->privateData)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- memHandle = h->privateData;
-
- switch (whence)
- {
- case MMFILE_SEEK_SET:
- tmp_offset = 0 + pos;
- break;
- case MMFILE_SEEK_CUR:
- tmp_offset = memHandle->offset + pos;
- break;
- case MMFILE_SEEK_END:
- tmp_offset = memHandle->size + pos;
- break;
- default:
- return MMFILE_IO_FAILED;
- }
-
- /*check validation*/
- if (tmp_offset < 0)
- {
- debug_error ("invalid file offset\n");
- return MMFILE_IO_FAILED;
- }
-
- /*set */
- memHandle->state = (tmp_offset >= memHandle->size) ? EOF : !EOF;
- memHandle->offset = tmp_offset;
-
- return memHandle->offset;
+ MMFmemIOHandle *memHandle = NULL;
+ long tmp_offset = 0;
+
+ if (!h || !h->privateData) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ memHandle = h->privateData;
+
+ switch (whence) {
+ case MMFILE_SEEK_SET:
+ tmp_offset = 0 + pos;
+ break;
+ case MMFILE_SEEK_CUR:
+ tmp_offset = memHandle->offset + pos;
+ break;
+ case MMFILE_SEEK_END:
+ tmp_offset = memHandle->size + pos;
+ break;
+ default:
+ return MMFILE_IO_FAILED;
+ }
+
+ /*check validation*/
+ if (tmp_offset < 0) {
+ debug_error("invalid file offset\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ /*set */
+ memHandle->state = (tmp_offset >= memHandle->size) ? EOF : !EOF;
+ memHandle->offset = tmp_offset;
+
+ return memHandle->offset;
}
-static long long mmf_mem_tell (MMFileIOHandle *h)
+static long long mmf_mem_tell(MMFileIOHandle *h)
{
- MMFmemIOHandle *memHandle = NULL;
+ MMFmemIOHandle *memHandle = NULL;
- if (!h || !h->privateData)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
+ if (!h || !h->privateData) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
- memHandle = h->privateData;
+ memHandle = h->privateData;
- return memHandle->offset;
+ return memHandle->offset;
}
-static int mmf_mem_close (MMFileIOHandle *h)
+static int mmf_mem_close(MMFileIOHandle *h)
{
- MMFmemIOHandle *memHandle = NULL;
+ MMFmemIOHandle *memHandle = NULL;
- if (!h || !h->privateData)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
+ if (!h || !h->privateData) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
- memHandle = h->privateData;
+ memHandle = h->privateData;
- if (memHandle)
- {
- mmfile_free (memHandle);
- h->privateData = NULL;
- }
+ if (memHandle) {
+ mmfile_free(memHandle);
+ h->privateData = NULL;
+ }
- return MMFILE_IO_SUCCESS;
+ return MMFILE_IO_SUCCESS;
}
mmf_mem_write,
mmf_mem_seek,
mmf_mem_tell,
- mmf_mem_close
+ mmf_mem_close,
+ NULL
};
-
-
-
*
*/
-
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int state;
} MMFMMapIOHandle;
-static int mmf_mmap_open (MMFileIOHandle *handle, const char *filename, int flags)
+static int mmf_mmap_open(MMFileIOHandle *handle, const char *filename, int flags)
{
- MMFMMapIOHandle *mmapHandle = NULL;
- struct stat finfo = {0, };
- int access = 0;
-
- if (!handle || !filename || !handle->iofunc || !handle->iofunc->handleName)
- {
- debug_error ("invalid param\n");
- return MMFILE_IO_FAILED;
- }
-
- filename += strlen(handle->iofunc->handleName) + 3; /* :// */
-
- memset (&finfo, 0x00, sizeof (struct stat));
-
- mmapHandle = mmfile_malloc (sizeof(MMFMMapIOHandle));
- if (!mmapHandle)
- {
- debug_error ("error: mmfile_malloc mmapHandle\n");
- return MMFILE_IO_FAILED;
- }
-
- if (flags & MMFILE_RDWR)
- {
- access = O_CREAT | O_TRUNC | O_RDWR;
- }
- else if (flags & MMFILE_WRONLY)
- {
- access = O_CREAT | O_TRUNC | O_WRONLY;
- }
- else
- {
- access = O_RDONLY;
- }
-
+ MMFMMapIOHandle *mmapHandle = NULL;
+ struct stat finfo = {0, };
+ int access = 0;
+
+ if (!handle || !filename || !handle->iofunc || !handle->iofunc->handleName) {
+ debug_error("invalid param\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ filename += strlen(handle->iofunc->handleName) + 3; /* :// */
+
+ memset(&finfo, 0x00, sizeof(struct stat));
+
+ mmapHandle = mmfile_malloc(sizeof(MMFMMapIOHandle));
+ if (!mmapHandle) {
+ debug_error("error: mmfile_malloc mmapHandle\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ if (flags & MMFILE_RDWR) {
+ access = O_CREAT | O_TRUNC | O_RDWR;
+ } else if (flags & MMFILE_WRONLY) {
+ access = O_CREAT | O_TRUNC | O_WRONLY;
+ } else {
+ access = O_RDONLY;
+ }
+
#ifdef O_BINARY
- access |= O_BINARY;
+ access |= O_BINARY;
#endif
- mmapHandle->fd = open (filename, access, 0666);
- if (mmapHandle->fd < 0)
- {
- debug_error ("error: open error: %s\n", filename);
- goto exception;
- }
-
- if (fstat (mmapHandle->fd, &finfo) == -1)
- {
- debug_error ("error: fstat\n");
- goto exception;
- }
-
- if (!S_ISREG(finfo.st_mode))
- {
- debug_error ("error: it is not regular file\n");
- goto exception;
- }
-
- mmapHandle->size = finfo.st_size;
- mmapHandle->offset = 0;
- mmapHandle->state = 0;
-
- if (flags & MMFILE_RDWR)
- {
- //mmapHandle->ptr = mmap64 (0, mmapHandle->size, PROT_WRITE | PROT_READ, MAP_SHARED, mmapHandle->fd, 0);
- mmapHandle->ptr = mmap (0, mmapHandle->size, PROT_WRITE | PROT_READ, MAP_SHARED, mmapHandle->fd, 0);
- }
- else if (flags & MMFILE_WRONLY)
- {
- //mmapHandle->ptr = mmap64 (0, mmapHandle->size, PROT_WRITE, MAP_SHARED, mmapHandle->fd, 0);
- mmapHandle->ptr = mmap (0, mmapHandle->size, PROT_WRITE, MAP_SHARED, mmapHandle->fd, 0);
- }
- else
- {
- //mmapHandle->ptr = mmap64 (0, mmapHandle->size, PROT_READ, MAP_SHARED, mmapHandle->fd, 0);
- mmapHandle->ptr = mmap (0, mmapHandle->size, PROT_READ, MAP_SHARED, mmapHandle->fd, 0);
- }
-
- if (mmapHandle->ptr == (void*)-1)
- {
- debug_error ("error: mmap\n");
- mmapHandle->ptr = NULL;
- goto exception;
- }
-
- handle->privateData = (void*) mmapHandle;
-
- return MMFILE_IO_SUCCESS;
+ mmapHandle->fd = open(filename, access, 0666);
+ if (mmapHandle->fd < 0) {
+ debug_error("error: open error: %s\n", filename);
+ goto exception;
+ }
+
+ if (fstat(mmapHandle->fd, &finfo) == -1) {
+ debug_error("error: fstat\n");
+ goto exception;
+ }
+
+ if (!S_ISREG(finfo.st_mode)) {
+ debug_error("error: it is not regular file\n");
+ goto exception;
+ }
+
+ mmapHandle->size = finfo.st_size;
+ mmapHandle->offset = 0;
+ mmapHandle->state = 0;
+
+ if (flags & MMFILE_RDWR) {
+ /*mmapHandle->ptr = mmap64(0, mmapHandle->size, PROT_WRITE | PROT_READ, MAP_SHARED, mmapHandle->fd, 0); */
+ mmapHandle->ptr = mmap(0, mmapHandle->size, PROT_WRITE | PROT_READ, MAP_SHARED, mmapHandle->fd, 0);
+ } else if (flags & MMFILE_WRONLY) {
+ /*mmapHandle->ptr = mmap64(0, mmapHandle->size, PROT_WRITE, MAP_SHARED, mmapHandle->fd, 0); */
+ mmapHandle->ptr = mmap(0, mmapHandle->size, PROT_WRITE, MAP_SHARED, mmapHandle->fd, 0);
+ } else {
+ /*mmapHandle->ptr = mmap64(0, mmapHandle->size, PROT_READ, MAP_SHARED, mmapHandle->fd, 0); */
+ mmapHandle->ptr = mmap(0, mmapHandle->size, PROT_READ, MAP_SHARED, mmapHandle->fd, 0);
+ }
+
+ if (mmapHandle->ptr == (void *)-1) {
+ debug_error("error: mmap\n");
+ mmapHandle->ptr = NULL;
+ goto exception;
+ }
+
+ handle->privateData = (void *) mmapHandle;
+
+ return MMFILE_IO_SUCCESS;
exception:
- if (mmapHandle)
- {
- if (mmapHandle->ptr)
- {
- munmap (mmapHandle->ptr, mmapHandle->size);
- }
-
- if (mmapHandle->fd > 2)
- {
- close (mmapHandle->fd);
- }
-
- mmfile_free (mmapHandle);
- handle->privateData = NULL;
- }
-
- return MMFILE_IO_FAILED;
+ if (mmapHandle) {
+ if (mmapHandle->ptr) {
+ munmap(mmapHandle->ptr, mmapHandle->size);
+ }
+
+ if (mmapHandle->fd > 2) {
+ close(mmapHandle->fd);
+ }
+
+ mmfile_free(mmapHandle);
+ handle->privateData = NULL;
+ }
+
+ return MMFILE_IO_FAILED;
}
-static int mmf_mmap_read (MMFileIOHandle *h, unsigned char *buf, int size)
+static int mmf_mmap_read(MMFileIOHandle *h, unsigned char *buf, int size)
{
- MMFMMapIOHandle *mmapHandle = NULL;
- const unsigned char *c = NULL;
- int len = 0;
-
- if (!h || !h->privateData || !buf)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- mmapHandle = h->privateData;
-
- c = mmapHandle->ptr + mmapHandle->offset;
-
- if (mmapHandle->state != EOF)
- {
- len = size;
- if (len + mmapHandle->offset > mmapHandle->size)
- {
- len = mmapHandle->size - mmapHandle->offset;
- }
- }
- else
- {
- return 0;
- }
-
- memcpy (buf, c, len);
-
- mmapHandle->offset += len;
-
- if ( mmapHandle->offset == mmapHandle->size)
- {
- mmapHandle->state = EOF;
- }
-
- return len;
+ MMFMMapIOHandle *mmapHandle = NULL;
+ const unsigned char *c = NULL;
+ int len = 0;
+
+ if (!h || !h->privateData || !buf) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ mmapHandle = h->privateData;
+
+ c = mmapHandle->ptr + mmapHandle->offset;
+
+ if (mmapHandle->state != EOF) {
+ len = size;
+ if (len + mmapHandle->offset > mmapHandle->size) {
+ len = mmapHandle->size - mmapHandle->offset;
+ }
+ } else {
+ return 0;
+ }
+
+ memcpy(buf, c, len);
+
+ mmapHandle->offset += len;
+
+ if (mmapHandle->offset == mmapHandle->size) {
+ mmapHandle->state = EOF;
+ }
+
+ return len;
}
-static int mmf_mmap_write (MMFileIOHandle *h, unsigned char *buf, int size)
+static int mmf_mmap_write(MMFileIOHandle *h, unsigned char *buf, int size)
{
- MMFMMapIOHandle *mmapHandle = NULL;
- unsigned char *c = NULL;
- int len = 0;
-
- if (!h || !h->privateData || !buf)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- mmapHandle = h->privateData;
-
- c = mmapHandle->ptr + mmapHandle->offset;
-
- if (mmapHandle->state != EOF)
- {
- len = size;
- if (len + mmapHandle->offset > mmapHandle->size)
- {
- len = mmapHandle->size - mmapHandle->offset;
- }
- }
- else
- {
- return 0;
- }
-
- memcpy (c, buf, len);
-
- mmapHandle->offset += len;
-
- if ( mmapHandle->offset == mmapHandle->size)
- {
- mmapHandle->state = EOF;
- }
-
- return len;
+ MMFMMapIOHandle *mmapHandle = NULL;
+ unsigned char *c = NULL;
+ int len = 0;
+
+ if (!h || !h->privateData || !buf) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ mmapHandle = h->privateData;
+
+ c = mmapHandle->ptr + mmapHandle->offset;
+
+ if (mmapHandle->state != EOF) {
+ len = size;
+ if (len + mmapHandle->offset > mmapHandle->size) {
+ len = mmapHandle->size - mmapHandle->offset;
+ }
+ } else {
+ return 0;
+ }
+
+ memcpy(c, buf, len);
+
+ mmapHandle->offset += len;
+
+ if (mmapHandle->offset == mmapHandle->size) {
+ mmapHandle->state = EOF;
+ }
+
+ return len;
}
-static long long mmf_mmap_seek (MMFileIOHandle *h, long long pos, int whence)
+static long long mmf_mmap_seek(MMFileIOHandle *h, long long pos, int whence)
{
- MMFMMapIOHandle *mmapHandle = NULL;
- long tmp_offset = 0;
-
- if (!h || !h->privateData)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- mmapHandle = h->privateData;
-
- switch (whence)
- {
- case SEEK_SET:
- tmp_offset = 0 + pos;
- break;
- case SEEK_CUR:
- tmp_offset = mmapHandle->offset + pos;
- break;
- case SEEK_END:
- tmp_offset = mmapHandle->size + pos;
- break;
- default:
- return MMFILE_IO_FAILED;
- }
-
- /*check validation*/
- if (tmp_offset < 0)
- {
- debug_error ("invalid file offset\n");
- return MMFILE_IO_FAILED;
- }
-
- /*set */
- mmapHandle->state = (tmp_offset >= mmapHandle->size) ? EOF : !EOF;
- mmapHandle->offset = tmp_offset;
-
- return mmapHandle->offset;
+ MMFMMapIOHandle *mmapHandle = NULL;
+ long tmp_offset = 0;
+
+ if (!h || !h->privateData) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ mmapHandle = h->privateData;
+
+ switch (whence) {
+ case SEEK_SET:
+ tmp_offset = 0 + pos;
+ break;
+ case SEEK_CUR:
+ tmp_offset = mmapHandle->offset + pos;
+ break;
+ case SEEK_END:
+ tmp_offset = mmapHandle->size + pos;
+ break;
+ default:
+ return MMFILE_IO_FAILED;
+ }
+
+ /*check validation*/
+ if (tmp_offset < 0) {
+ debug_error("invalid file offset\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ /*set */
+ mmapHandle->state = (tmp_offset >= mmapHandle->size) ? EOF : !EOF;
+ mmapHandle->offset = tmp_offset;
+
+ return mmapHandle->offset;
}
-static long long mmf_mmap_tell (MMFileIOHandle *h)
+static long long mmf_mmap_tell(MMFileIOHandle *h)
{
- MMFMMapIOHandle *mmapHandle = NULL;
+ MMFMMapIOHandle *mmapHandle = NULL;
- if (!h || !h->privateData)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
+ if (!h || !h->privateData) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
- mmapHandle = h->privateData;
+ mmapHandle = h->privateData;
- return mmapHandle->offset;
+ return mmapHandle->offset;
}
-static int mmf_mmap_close (MMFileIOHandle *h)
+static int mmf_mmap_close(MMFileIOHandle *h)
{
- MMFMMapIOHandle *mmapHandle = NULL;
-
- if (!h || !h->privateData)
- {
- debug_error ("invalid para\n");
- return MMFILE_IO_FAILED;
- }
-
- mmapHandle = h->privateData;
-
- if (mmapHandle)
- {
- if (mmapHandle->ptr)
- {
- munmap (mmapHandle->ptr, mmapHandle->size);
- }
-
- if (mmapHandle->fd > 2)
- {
- close (mmapHandle->fd);
- }
-
- mmfile_free (mmapHandle);
- }
-
- h->privateData = NULL;
-
- return MMFILE_IO_SUCCESS;
+ MMFMMapIOHandle *mmapHandle = NULL;
+
+ if (!h || !h->privateData) {
+ debug_error("invalid para\n");
+ return MMFILE_IO_FAILED;
+ }
+
+ mmapHandle = h->privateData;
+
+ if (mmapHandle) {
+ if (mmapHandle->ptr) {
+ munmap(mmapHandle->ptr, mmapHandle->size);
+ }
+
+ if (mmapHandle->fd > 2) {
+ close(mmapHandle->fd);
+ }
+
+ mmfile_free(mmapHandle);
+ }
+
+ h->privateData = NULL;
+
+ return MMFILE_IO_SUCCESS;
}
mmf_mmap_write,
mmf_mmap_seek,
mmf_mmap_tell,
- mmf_mmap_close
+ mmf_mmap_close,
+ NULL
};
#include "mm_file_utils.h"
EXPORT_API
-MMFileList mmfile_list_alloc ()
+MMFileList mmfile_list_alloc()
{
- return g_list_alloc ();
+ return g_list_alloc();
}
EXPORT_API
-MMFileList mmfile_list_append (MMFileList list, void* data)
+MMFileList mmfile_list_append(MMFileList list, void *data)
{
- return g_list_append (list, data);
+ return g_list_append(list, data);
}
EXPORT_API
-MMFileList mmfile_list_prepend (MMFileList list, void* data)
+MMFileList mmfile_list_prepend(MMFileList list, void *data)
{
- return g_list_prepend (list, data);
+ return g_list_prepend(list, data);
}
EXPORT_API
-MMFileList mmfile_list_find (MMFileList list, void* data)
+MMFileList mmfile_list_find(MMFileList list, void *data)
{
- return g_list_find (list, data);
+ return g_list_find(list, data);
}
EXPORT_API
-MMFileList mmfile_list_first (MMFileList list)
+MMFileList mmfile_list_first(MMFileList list)
{
- return g_list_first (list);
+ return g_list_first(list);
}
EXPORT_API
-MMFileList mmfile_list_last (MMFileList list)
+MMFileList mmfile_list_last(MMFileList list)
{
- return g_list_last (list);
+ return g_list_last(list);
}
EXPORT_API
-MMFileList mmfile_list_nth (MMFileList list, unsigned int n)
+MMFileList mmfile_list_nth(MMFileList list, unsigned int n)
{
- return g_list_nth (list, n);
+ return g_list_nth(list, n);
}
EXPORT_API
-MMFileList mmfile_list_next (MMFileList list)
+MMFileList mmfile_list_next(MMFileList list)
{
- return g_list_next (list);
+ return g_list_next(list);
}
EXPORT_API
-MMFileList mmfile_list_previous (MMFileList list)
+MMFileList mmfile_list_previous(MMFileList list)
{
- return g_list_previous (list);
+ return g_list_previous(list);
}
EXPORT_API
-unsigned int mmfile_list_length (MMFileList list)
+unsigned int mmfile_list_length(MMFileList list)
{
- return g_list_length (list);
+ return g_list_length(list);
}
EXPORT_API
-MMFileList mmfile_list_remove (MMFileList list, void *data)
+MMFileList mmfile_list_remove(MMFileList list, void *data)
{
- return g_list_remove (list, data);
+ return g_list_remove(list, data);
}
EXPORT_API
-MMFileList mmfile_list_remove_all (MMFileList list, void *data)
+MMFileList mmfile_list_remove_all(MMFileList list, void *data)
{
- return g_list_remove_all (list, data);
+ return g_list_remove_all(list, data);
}
EXPORT_API
-MMFileList mmfile_list_reverse (MMFileList list)
+MMFileList mmfile_list_reverse(MMFileList list)
{
- return g_list_reverse (list);
+ return g_list_reverse(list);
}
EXPORT_API
-void mmfile_list_free (MMFileList list)
+void mmfile_list_free(MMFileList list)
{
- g_list_free (list);
+ g_list_free(list);
}
/* This macro is the same with global-gconf.h */
#define MMFILE_LANGUAGETYPE_REPOSITORY "/Apps/Settings/language_type"
-typedef enum
-{
+typedef enum {
MMFILE_LANGUAGE_ENGLISH = 0x00, /**<Language - English*/
MMFILE_LANGUAGE_GERMAN, /**<Language - German*/
MMFILE_LANGUAGE_FRENCH, /**<Language - French*/
MMFILE_LANGUAGE_SIM_CHINA, /**<Language - Simplified Chinese*/
MMFILE_LANGUAGE_TRA_CHINA, /**<Language - Traditional Chinese*/
MMFILE_LANGUAGE_JAPAN, /**<Language - Japanease*/
-#if 0
+#if 0
MMFILE_LANGUAGE_BULGARIAN, /**<Language - Bulgarian*/
MMFILE_LANGUAGE_ARABIC, /**<Language - Arabic*/
#endif
- MMFILE_LANGUAGE_MAX
+ MMFILE_LANGUAGE_MAX
} eMMFileSettingPhoneLanguage;
-const char *MMFILE_LOCALE_TABLE [MMFILE_LANGUAGE_MAX] =
-{
+const char *MMFILE_LOCALE_TABLE[MMFILE_LANGUAGE_MAX] = {
"EUC-KR", /* Temporally - Language - English */
"ISO8859-1", /* Language - German */
"ISO8859-1", /* Language - French */
"BIG5", /* Language - Traditional Chinese */
"SHIFT_JIS" /* Language - Japanease */
#if 0
- /* Language - Bulgarian */
- /* Language - Arabic */
+ /* Language - Bulgarian */
+ /* Language - Arabic */
#endif
};
const char *eng_prefix = "en";
const char *china_lang = "zh_CN";
- const char *hongkong_lang = "zh_HK";
- const char *taiwan_lang = "zh_TW";
+ /*const char *hongkong_lang = "zh_HK";*/
+ /*const char *taiwan_lang = "zh_TW";*/
const char *jpn_lang = "ja_JP";
lang = vconf_get_str(VCONFKEY_LANGSET);
if (lang != NULL) {
- if (strncmp(lang,china_prefix, strlen(china_prefix)) == 0) {
+ if (strncmp(lang, china_prefix, strlen(china_prefix)) == 0) {
/* This case is selected language is china */
if (strncmp(lang, china_lang, strlen(china_lang)) == 0) {
debug_msg("[%s]character set is simplified chinese", lang);
index = MMFILE_LANGUAGE_ENGLISH;
}
- if(lang) {
+ if (lang) {
free(lang);
lang = NULL;
}
}
EXPORT_API
-char *MMFileUtilGetLocale (int *error)
+char *MMFileUtilGetLocale(int *error)
{
int index = 0;
int err = 0;
index = _MMFileUtilGetLocaleindex();
- if (index < 0 || index >= MMFILE_LANGUAGE_MAX)
- {
- debug_error ("invalid index\n");
+ if (index < 0 || index >= MMFILE_LANGUAGE_MAX) {
+ debug_error("invalid index\n");
err = MMFILE_UTIL_FAIL;
return NULL;
}
err = MMFILE_UTIL_SUCCESS;
- if (error)
- {
+ if (error) {
*error = err;
}
#ifdef __MMFILE_MEM_TRACE__
EXPORT_API
-void *mmfile_malloc_debug (unsigned int size, const char *func, unsigned int line)
+void *mmfile_malloc_debug(unsigned int size, const char *func, unsigned int line)
{
- void *tmp = malloc (size);
+ void *tmp = malloc(size);
if (tmp) {
- memset (tmp, 0x00, size);
- #ifdef __MMFILE_TEST_MODE__
+ memset(tmp, 0x00, size);
+#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## %p = malloc (%d) by %s() %d\n", tmp, size, func, line);
- #endif
+#endif
}
return tmp;
}
EXPORT_API
-void *mmfile_calloc_debug (unsigned int nmemb, unsigned int size, const char *func, unsigned int line)
+void *mmfile_calloc_debug(unsigned int nmemb, unsigned int size, const char *func, unsigned int line)
{
- void *tmp = calloc (nmemb, size);
+ void *tmp = calloc(nmemb, size);
if (tmp) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## %p = calloc (%d, %d) by %s() %d\n", tmp, nmemb, size, func, line);
- #endif
+#endif
}
return tmp;
}
EXPORT_API
-void mmfile_free_debug (void *ptr, const char *func, unsigned int line)
+void mmfile_free_debug(void *ptr, const char *func, unsigned int line)
{
if (ptr) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## free (%p) by %s() %d\n", ptr, func, line);
- #endif
- free (ptr);
+#endif
+ free(ptr);
}
}
EXPORT_API
-void *mmfile_realloc_debug (void *ptr, unsigned int size, const char *func, unsigned int line)
+void *mmfile_realloc_debug(void *ptr, unsigned int size, const char *func, unsigned int line)
{
- void *tmp = realloc (ptr, size);
+ void *tmp = realloc(ptr, size);
if (tmp) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## %p = realloc (%p, %d) by %s() %d\n", tmp, ptr, size, func, line);
- #endif
+#endif
}
return tmp;
}
EXPORT_API
-void *mmfile_memset_debug (void *s, int c, unsigned int n, const char *func, unsigned int line)
+void *mmfile_memset_debug(void *s, int c, unsigned int n, const char *func, unsigned int line)
{
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## memset (%p, %d, %d) by %s() %d\n", s, c, n, func, line);
- #endif
- return memset (s, c, n);
+#endif
+ return memset(s, c, n);
}
EXPORT_API
-void *mmfile_memcpy_debug (void *dest, const void *src, unsigned int n, const char *func, unsigned int line)
+void *mmfile_memcpy_debug(void *dest, const void *src, unsigned int n, const char *func, unsigned int line)
{
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## memcpy (%p, %p, %d) by %s() %d\n", dest, src, n, func, line);
- #endif
- return memcpy (dest, src, n);
+#endif
+ return memcpy(dest, src, n);
}
#else /* __MMFILE_MEM_TRACE__ : ------------------------------------------------------------------*/
EXPORT_API
-void *mmfile_malloc (unsigned int size)
+void *mmfile_malloc(unsigned int size)
{
- void *tmp = malloc (size);
- if (tmp)
- {
- memset (tmp, 0x00, size);
- }
- return tmp;
+ void *tmp = malloc(size);
+ if (tmp) {
+ memset(tmp, 0x00, size);
+ }
+ return tmp;
}
EXPORT_API
-void *mmfile_calloc (unsigned int nmemb, unsigned int size)
+void *mmfile_calloc(unsigned int nmemb, unsigned int size)
{
- void *tmp = calloc (nmemb, size);
- return tmp;
+ void *tmp = calloc(nmemb, size);
+ return tmp;
}
EXPORT_API
-void mmfile_free_r (void *ptr)
+void mmfile_free_r(void *ptr)
{
- if (ptr) free (ptr);
+ if (ptr) free(ptr);
}
EXPORT_API
-void *mmfile_realloc (void *ptr, unsigned int size)
+void *mmfile_realloc(void *ptr, unsigned int size)
{
- return realloc (ptr, size);
+ return realloc(ptr, size);
}
EXPORT_API
-void *mmfile_memset (void *s, int c, unsigned int n)
+void *mmfile_memset(void *s, int c, unsigned int n)
{
- return memset (s, c, n);
+ return memset(s, c, n);
}
EXPORT_API
-void *mmfile_memcpy (void *dest, const void *src, unsigned int n)
+void *mmfile_memcpy(void *dest, const void *src, unsigned int n)
{
- return memcpy (dest, src, n);
+ return memcpy(dest, src, n);
}
#endif
#include "mm_file_debug.h"
#include "mm_file_utils.h"
-typedef struct _mmfileavmimetype
-{
- char mimetype[MMFILE_MIMETYPE_MAX_LEN];
- char ffmpegFormat[MMFILE_FILE_FMT_MAX_LEN];
- char extension[MMFILE_FILE_EXT_MAX_LEN];
+typedef struct _mmfileavmimetype {
+ char mimetype[MMFILE_MIMETYPE_MAX_LEN];
+ char ffmpegFormat[MMFILE_FILE_FMT_MAX_LEN];
+ char extension[MMFILE_FILE_EXT_MAX_LEN];
} MMFileAVMimeType;
-const MMFileAVMimeType MMFILE_FFMPEG_MIME_TABLE [] =
-{
- {"audio/mpeg", "mp3", "mp3"},
- {"audio/mp3", "mp3", "mp3"},
- {"audio/mpg3", "mp3", "mp3"},
- {"audio/mpeg3", "mp3", "mp3"},
- {"audio/mpg", "mp3", "mp3"},
- {"audio/x-mpeg", "mp3", "mp3"},
- {"audio/x-mp3", "mp3", "mp3"},
- {"audio/x-mpeg3", "mp3", "mp3"},
- {"audio/x-mpg", "mp3", "mp3"},
- {"audio/x-mpegaudio", "mp3", "mp3"}, //10
-
- {"video/3gpp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
- {"video/h263", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
- {"video/3gp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
- {"video/3gpp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
- {"video/mp4v-es", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"video/mpeg", "mov,mp4,m4a,3gp,3g2,mj2", "mpeg"},
- {"video/dvd", "mov,mp4,m4a,3gp,3g2,mj2", "mpeg"},
- {"audio/3gpp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"}, //17
-
- {"video/mpeg4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"video/mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"video/x-mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"video/x-pv-mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"audio/mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"audio/MP4A-LATM", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"audio/mpeg4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
- {"audio/m4a", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"}, //25
-
- {"video/avi", "avi", "avi"},
- {"video/divx", "divx", "divx"},
-
- {"audio/x-ms-asf", "asf", "asf"},
- {"video/x-ms-asf", "asf", "asf"},
- {"video/x-ms-asf", "asf", "asf"},
-
- {"video/x-ms-wmv", "asf", "wmv"},
- {"audio/wma", "asf", "wma"},
- {"audio/x-ms-wma", "asf", "wma"},
-
- {"audio/wave", "wav", "wav"}, /* Not Sure */
- {"audio/wav", "wav", "wav"}, /* Not Sure */
- {"audio/x-wave", "wav", "wav"}, /* Not Sure */
- {"audio/x-wav", "wav", "wav"}, /* Not Sure */
-
- {"audio/aac", "aac", "aac"}, /* Not Sure */
- {"audio/g72", "aac", "aac"}, /* Not Sure */ //39
-
- {"audio/AMR", "amr", "amr"}, /* Not Sure */
- {"audio/amr-wb", "amr", "amr"}, /* Not Sure */
- {"audio/x-amr", "amr", "amr"}, /* Not Sure */
-
- {"audio/x-mid", "mid", "mid"}, /* Not Sure */
- {"audio/x-midi", "mid", "mid"}, /* Not Sure */
- {"audio/mid", "mid", "mid"}, /* Not Sure */
- {"audio/midi", "mid", "mid"}, /* Not Sure */
- {"audio/mid", "mid", "mid"}, /* Not Sure */ //47
-
- {"audio/iMelody", "imy", "imy"}, /* Not Sure */
- {"audio/imelody", "imy", "imy"}, /* Not Sure */
- {"audio/melody", "imy", "imy"}, /* Not Sure */
- {"audio/imy", "imy", "imy"}, /* Not Sure */
- {"audio/x-iMelody", "imy", "imy"}, /* Not Sure */
-
- {"audio/basic", "snd", ""}, /* Not Sure */
- {"audio/pmd", "pmd", ""}, /* Not Sure */
- {"audio/sp-midi", "smp", ""}, /* Not Sure */ //55
-
- {"audio/mmf", "mmf", "mmf"}, /* Not Sure */
- {"audio/smaf", "mmf", "mmf"}, /* Not Sure */
- {"audio/x-mmf", "mmf", "mmf"}, /* Not Sure */
- {"audio/x-smaf", "mmf", "mmf"}, /* Not Sure */
-
- {"audio/xmf", "xmf", "xmf"}, /* Not Sure */
- {"audio/mobile-xmf", "xmf", "xmf"}, /* Not Sure */
- {"audio/x-xmf", "xmf", "xmf"}, /* Not Sure */ //62
-
- {"audio/vnd.rn-realaudio", "rm", ""}, /* Not Sure */
- {"audio/x-pn-multirate-realaudio", "rm", ""}, /* Not Sure */
- {"audio/x-pn-multirate-realaudio-live", "rm", ""}, /* Not Sure */
- {"video/vnd.rn-realvideo", "rm", ""}, /* Not Sure */
- {"video/vnd.rn-realmedia", "rm", ""}, /* Not Sure */
- {"video/x-pn-multirate-realvideo", "rm", ""}, /* Not Sure */ //68
-
- {"video/ogg", "ogg", "ogg"},
- {"video/theora", "ogg", "ogg"},
- {"audio/ogg", "ogg", "ogg"},
- {"audio/x-ogg", "ogg", "ogg"},
- {"audio/vorbis", "ogg", "ogg"}, //73
-
- {"audio/x-flac", "flac", "flac"}, //74
- {"video/x-flv", "flv", "flv"}, //75
- {"video/MP2T", "mpegts", "ts"},
- {"video/MP2P", "mpeg", "mpg"},
- {"video/mpeg", "mpegvideo", "mpeg"}, //mpeg 1 video
+const MMFileAVMimeType MMFILE_FFMPEG_MIME_TABLE[] = {
+ {"audio/mpeg", "mp3", "mp3"},
+ {"audio/mp3", "mp3", "mp3"},
+ {"audio/mpg3", "mp3", "mp3"},
+ {"audio/mpeg3", "mp3", "mp3"},
+ {"audio/mpg", "mp3", "mp3"},
+ {"audio/x-mpeg", "mp3", "mp3"},
+ {"audio/x-mp3", "mp3", "mp3"},
+ {"audio/x-mpeg3", "mp3", "mp3"},
+ {"audio/x-mpg", "mp3", "mp3"},
+ {"audio/x-mpegaudio", "mp3", "mp3"}, /*10 */
+
+ {"video/3gpp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
+ {"video/h263", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
+ {"video/3gp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
+ {"video/3gpp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"},
+ {"video/mp4v-es", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"video/dvd", "mov,mp4,m4a,3gp,3g2,mj2", "mpeg"},
+ {"audio/3gpp", "mov,mp4,m4a,3gp,3g2,mj2", "3gp"}, /*17 */
+
+ {"video/mpeg4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"video/mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"video/x-mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"video/x-pv-mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"audio/mp4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"audio/MP4A-LATM", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"audio/mpeg4", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"},
+ {"audio/m4a", "mov,mp4,m4a,3gp,3g2,mj2", "mp4"}, /*25 */
+
+ {"video/avi", "avi", "avi"},
+ {"video/divx", "divx", "divx"},
+
+ {"audio/x-ms-asf", "asf", "asf"},
+ {"video/x-ms-asf", "asf", "asf"},
+ {"video/x-ms-asf", "asf", "asf"},
+
+ {"video/x-ms-wmv", "asf", "wmv"},
+ {"audio/wma", "asf", "wma"},
+ {"audio/x-ms-wma", "asf", "wma"},
+
+ {"audio/wave", "wav", "wav"}, /* Not Sure */
+ {"audio/wav", "wav", "wav"}, /* Not Sure */
+ {"audio/x-wave", "wav", "wav"}, /* Not Sure */
+ {"audio/x-wav", "wav", "wav"}, /* Not Sure */
+
+ {"audio/aac", "aac", "aac"}, /* Not Sure */
+ {"audio/g72", "aac", "aac"}, /* Not Sure */ /*39 */
+
+ {"audio/AMR", "amr", "amr"}, /* Not Sure */
+ {"audio/amr-wb", "amr", "amr"}, /* Not Sure */
+ {"audio/x-amr", "amr", "amr"}, /* Not Sure */
+
+ {"audio/x-mid", "mid", "mid"}, /* Not Sure */
+ {"audio/x-midi", "mid", "mid"}, /* Not Sure */
+ {"audio/mid", "mid", "mid"}, /* Not Sure */
+ {"audio/midi", "mid", "mid"}, /* Not Sure */
+ {"audio/mid", "mid", "mid"}, /* Not Sure */ /*47 */
+
+ {"audio/iMelody", "imy", "imy"}, /* Not Sure */
+ {"audio/imelody", "imy", "imy"}, /* Not Sure */
+ {"audio/melody", "imy", "imy"}, /* Not Sure */
+ {"audio/imy", "imy", "imy"}, /* Not Sure */
+ {"audio/x-iMelody", "imy", "imy"}, /* Not Sure */
+
+ {"audio/basic", "snd", ""}, /* Not Sure */
+ {"audio/pmd", "pmd", ""}, /* Not Sure */
+ {"audio/sp-midi", "smp", ""}, /* Not Sure */ /*55 */
+
+ {"audio/mmf", "mmf", "mmf"}, /* Not Sure */
+ {"audio/smaf", "mmf", "mmf"}, /* Not Sure */
+ {"audio/x-mmf", "mmf", "mmf"}, /* Not Sure */
+ {"audio/x-smaf", "mmf", "mmf"}, /* Not Sure */
+
+ {"audio/xmf", "xmf", "xmf"}, /* Not Sure */
+ {"audio/mobile-xmf", "xmf", "xmf"}, /* Not Sure */
+ {"audio/x-xmf", "xmf", "xmf"}, /* Not Sure */ /*62 */
+
+ {"audio/vnd.rn-realaudio", "rm", ""}, /* Not Sure */
+ {"audio/x-pn-multirate-realaudio", "rm", ""}, /* Not Sure */
+ {"audio/x-pn-multirate-realaudio-live", "rm", ""}, /* Not Sure */
+ {"video/vnd.rn-realvideo", "rm", ""}, /* Not Sure */
+ {"video/vnd.rn-realmedia", "rm", ""}, /* Not Sure */
+ {"video/x-pn-multirate-realvideo", "rm", ""}, /* Not Sure */ /*68 */
+
+ {"video/ogg", "ogg", "ogg"},
+ {"video/theora", "ogg", "ogg"},
+ {"audio/ogg", "ogg", "ogg"},
+ {"audio/x-ogg", "ogg", "ogg"},
+ {"audio/vorbis", "ogg", "ogg"}, /*73 */
+
+ {"audio/x-flac", "flac", "flac"}, /*74 */
+ {"video/x-flv", "flv", "flv"}, /*75 */
+ {"video/MP2T", "mpegts", "ts"},
+ {"video/MP2P", "mpeg", "mpg"},
+ {"video/mpeg", "mpegvideo", "mpeg"}, /*mpeg 1 video */
};
EXPORT_API
-int mmfile_util_get_ffmpeg_format (const char *mime, char *ffmpegFormat)
+int mmfile_util_get_ffmpeg_format(const char *mime, char *ffmpegFormat)
{
- int i = 0;
+ int i = 0;
int table_size = sizeof(MMFILE_FFMPEG_MIME_TABLE) / sizeof(MMFileAVMimeType);
- if ( NULL == mime || NULL == ffmpegFormat)
- {
- debug_error ("error: mmfile_util_get_format\n");
- return MMFILE_UTIL_FAIL;
- }
-
- for (i = 0; i < table_size; i++)
- {
- if (!strcasecmp (MMFILE_FFMPEG_MIME_TABLE[i].mimetype, mime))
- {
- break;
- }
- }
-
- if (i == table_size)
- {
- debug_error ("error: not found[%s]\n", mime);
- return MMFILE_UTIL_FAIL;
- }
-
- memcpy (ffmpegFormat, MMFILE_FFMPEG_MIME_TABLE[i].ffmpegFormat, strlen(MMFILE_FFMPEG_MIME_TABLE[i].ffmpegFormat));
-
- return MMFILE_UTIL_SUCCESS;
+ if (NULL == mime || NULL == ffmpegFormat) {
+ debug_error("error: mmfile_util_get_format\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ for (i = 0; i < table_size; i++) {
+ if (!strcasecmp(MMFILE_FFMPEG_MIME_TABLE[i].mimetype, mime)) {
+ break;
+ }
+ }
+
+ if (i == table_size) {
+ debug_error("error: not found[%s]\n", mime);
+ return MMFILE_UTIL_FAIL;
+ }
+
+ memcpy(ffmpegFormat, MMFILE_FFMPEG_MIME_TABLE[i].ffmpegFormat, strlen(MMFILE_FFMPEG_MIME_TABLE[i].ffmpegFormat));
+
+ return MMFILE_UTIL_SUCCESS;
}
EXPORT_API
-int mmfile_util_get_file_ext (const char *mime, char *ext)
+int mmfile_util_get_file_ext(const char *mime, char *ext)
{
- int i = 0;
+ int i = 0;
int table_size = sizeof(MMFILE_FFMPEG_MIME_TABLE) / sizeof(MMFileAVMimeType);
- if ( NULL == mime || NULL == ext)
- {
- debug_error ("error: mmfile_util_get_file_ext\n");
- return MMFILE_UTIL_FAIL;
- }
-
- for (i = 0; i < table_size; i++)
- {
- if (!strcasecmp (MMFILE_FFMPEG_MIME_TABLE[i].mimetype, mime))
- {
- break;
- }
- }
-
- if (i == table_size)
- {
- debug_error ("error: not found[%s]\n", mime);
- return MMFILE_UTIL_FAIL;
- }
-
- memcpy (ext, MMFILE_FFMPEG_MIME_TABLE[i].extension, strlen(MMFILE_FFMPEG_MIME_TABLE[i].extension));
-
- return MMFILE_UTIL_SUCCESS;
+ if (NULL == mime || NULL == ext) {
+ debug_error("error: mmfile_util_get_file_ext\n");
+ return MMFILE_UTIL_FAIL;
+ }
+
+ for (i = 0; i < table_size; i++) {
+ if (!strcasecmp(MMFILE_FFMPEG_MIME_TABLE[i].mimetype, mime)) {
+ break;
+ }
+ }
+
+ if (i == table_size) {
+ debug_error("error: not found[%s]\n", mime);
+ return MMFILE_UTIL_FAIL;
+ }
+
+ memcpy(ext, MMFILE_FFMPEG_MIME_TABLE[i].extension, strlen(MMFILE_FFMPEG_MIME_TABLE[i].extension));
+
+ return MMFILE_UTIL_SUCCESS;
}
#include "mm_file_utils.h"
EXPORT_API
-void mmfile_format_print_contents (MMFileFormatContext *in)
+void mmfile_format_print_contents(MMFileFormatContext *in)
{
if (in) {
- debug_msg ("formatType = %d\n", in->formatType);
- debug_msg ("commandType = %d\n", in->commandType);
- debug_msg ("duration = %d\n", in->duration);
- debug_msg ("videoTotalTrackNum = %d\n", in->videoTotalTrackNum);
- debug_msg ("audioTotalTrackNum = %d\n", in->audioTotalTrackNum);
- debug_msg ("nbStreams = %d\n", in->nbStreams);
- debug_msg ("audioStreamId = %d\n", in->audioStreamId);
- debug_msg ("videoStreamId = %d\n", in->videoStreamId);
+ debug_msg("formatType = %d\n", in->formatType);
+ debug_msg("commandType = %d\n", in->commandType);
+ debug_msg("duration = %d\n", in->duration);
+ debug_msg("videoTotalTrackNum = %d\n", in->videoTotalTrackNum);
+ debug_msg("audioTotalTrackNum = %d\n", in->audioTotalTrackNum);
+ debug_msg("nbStreams = %d\n", in->nbStreams);
+ debug_msg("audioStreamId = %d\n", in->audioStreamId);
+ debug_msg("videoStreamId = %d\n", in->videoStreamId);
if (in->videoTotalTrackNum > 0 && in->streams[MMFILE_VIDEO_STREAM]) {
- debug_msg ("VstreamType = %d\n", in->streams[MMFILE_VIDEO_STREAM]->streamType);
- debug_msg ("VcodecId = %d\n", in->streams[MMFILE_VIDEO_STREAM]->codecId);
- debug_msg ("VbitRate = %d\n", in->streams[MMFILE_VIDEO_STREAM]->bitRate);
- debug_msg ("VframePerSec = %d\n", in->streams[MMFILE_VIDEO_STREAM]->framePerSec);
- debug_msg ("Vwidth = %d\n", in->streams[MMFILE_VIDEO_STREAM]->width);
- debug_msg ("Vheight = %d\n", in->streams[MMFILE_VIDEO_STREAM]->height);
- debug_msg ("VnbChannel = %d\n", in->streams[MMFILE_VIDEO_STREAM]->nbChannel);
- debug_msg ("VsamplePerSec = %d\n", in->streams[MMFILE_VIDEO_STREAM]->samplePerSec);
+ debug_msg("VstreamType = %d\n", in->streams[MMFILE_VIDEO_STREAM]->streamType);
+ debug_msg("VcodecId = %d\n", in->streams[MMFILE_VIDEO_STREAM]->codecId);
+ debug_msg("VbitRate = %d\n", in->streams[MMFILE_VIDEO_STREAM]->bitRate);
+ debug_msg("VframePerSec = %d\n", in->streams[MMFILE_VIDEO_STREAM]->framePerSec);
+ debug_msg("Vwidth = %d\n", in->streams[MMFILE_VIDEO_STREAM]->width);
+ debug_msg("Vheight = %d\n", in->streams[MMFILE_VIDEO_STREAM]->height);
+ debug_msg("VnbChannel = %d\n", in->streams[MMFILE_VIDEO_STREAM]->nbChannel);
+ debug_msg("VsamplePerSec = %d\n", in->streams[MMFILE_VIDEO_STREAM]->samplePerSec);
}
if (in->audioTotalTrackNum > 0 && in->streams[MMFILE_AUDIO_STREAM]) {
- debug_msg ("AstreamType = %d\n", in->streams[MMFILE_AUDIO_STREAM]->streamType);
- debug_msg ("AcodecId = %d\n", in->streams[MMFILE_AUDIO_STREAM]->codecId);
- debug_msg ("AbitRate = %d\n", in->streams[MMFILE_AUDIO_STREAM]->bitRate);
- debug_msg ("AframePerSec = %d\n", in->streams[MMFILE_AUDIO_STREAM]->framePerSec);
- debug_msg ("Awidth = %d\n", in->streams[MMFILE_AUDIO_STREAM]->width);
- debug_msg ("Aheight = %d\n", in->streams[MMFILE_AUDIO_STREAM]->height);
- debug_msg ("AnbChannel = %d\n", in->streams[MMFILE_AUDIO_STREAM]->nbChannel);
- debug_msg ("AsamplePerSec = %d\n", in->streams[MMFILE_AUDIO_STREAM]->samplePerSec);
+ debug_msg("AstreamType = %d\n", in->streams[MMFILE_AUDIO_STREAM]->streamType);
+ debug_msg("AcodecId = %d\n", in->streams[MMFILE_AUDIO_STREAM]->codecId);
+ debug_msg("AbitRate = %d\n", in->streams[MMFILE_AUDIO_STREAM]->bitRate);
+ debug_msg("AframePerSec = %d\n", in->streams[MMFILE_AUDIO_STREAM]->framePerSec);
+ debug_msg("Awidth = %d\n", in->streams[MMFILE_AUDIO_STREAM]->width);
+ debug_msg("Aheight = %d\n", in->streams[MMFILE_AUDIO_STREAM]->height);
+ debug_msg("AnbChannel = %d\n", in->streams[MMFILE_AUDIO_STREAM]->nbChannel);
+ debug_msg("AsamplePerSec = %d\n", in->streams[MMFILE_AUDIO_STREAM]->samplePerSec);
}
}
}
EXPORT_API
-void mmfile_format_print_tags (MMFileFormatContext *in)
+void mmfile_format_print_tags(MMFileFormatContext *in)
{
if (in) {
- if (in->title) debug_msg ("title = %s\n", in->title);
- if (in->artist) debug_msg ("artist = %s\n", in->artist);
- if (in->author) debug_msg ("author = %s\n", in->author);
- if (in->composer) debug_msg ("composer = %s\n", in->composer);
- if (in->album) debug_msg ("album = %s\n", in->album);
- if (in->album_artist) debug_msg ("album_artist = %s\n", in->album_artist);
- if (in->copyright) debug_msg ("copyright = %s\n", in->copyright);
- if (in->comment) debug_msg ("comment = %s\n", in->comment);
- if (in->genre) debug_msg ("genre = %s\n", in->genre);
- if (in->year) debug_msg ("year = %s\n", in->year);
- if (in->recDate) debug_msg ("recDate = %s\n", in->recDate);
- if (in->tagTrackNum) debug_msg ("tagTrackNum = %s\n", in->tagTrackNum);
- if (in->artworkMime) debug_msg ("artworkMime = %s\n", in->artworkMime);
- debug_msg ("artworksize = %d\n", in->artworkSize);
- if (in->artwork) debug_msg ("artwork = %p\n", in->artwork);
- if (in->classification) debug_msg ("classification = %s\n", in->classification);
+ if (in->title) debug_msg("title = %s\n", in->title);
+ if (in->artist) debug_msg("artist = %s\n", in->artist);
+ if (in->author) debug_msg("author = %s\n", in->author);
+ if (in->composer) debug_msg("composer = %s\n", in->composer);
+ if (in->album) debug_msg("album = %s\n", in->album);
+ if (in->album_artist) debug_msg("album_artist = %s\n", in->album_artist);
+ if (in->copyright) debug_msg("copyright = %s\n", in->copyright);
+ if (in->comment) debug_msg("comment = %s\n", in->comment);
+ if (in->genre) debug_msg("genre = %s\n", in->genre);
+ if (in->year) debug_msg("year = %s\n", in->year);
+ if (in->recDate) debug_msg("recDate = %s\n", in->recDate);
+ if (in->tagTrackNum) debug_msg("tagTrackNum = %s\n", in->tagTrackNum);
+ if (in->artworkMime) debug_msg("artworkMime = %s\n", in->artworkMime);
+ debug_msg("artworksize = %d\n", in->artworkSize);
+ if (in->artwork) debug_msg("artwork = %p\n", in->artwork);
+ if (in->classification) debug_msg("classification = %s\n", in->classification);
}
}
EXPORT_API
-void mmfile_format_print_frame (MMFileFormatFrame *in)
+void mmfile_format_print_frame(MMFileFormatFrame *in)
{
if (in) {
- debug_msg ("in->bCompressed = %d\n", in->bCompressed);
- debug_msg ("in->frameData = %p\n", in->frameData);
- debug_msg ("in->frameHeight = %d\n", in->frameHeight);
- debug_msg ("in->frameWidth = %d\n", in->frameWidth);
- debug_msg ("in->frameSize = %d\n", in->frameSize);
- debug_msg ("in->configLenth = %d\n", in->configLenth);
- debug_msg ("in->configData = %p\n", in->configData);
+ debug_msg("in->bCompressed = %d\n", in->bCompressed);
+ debug_msg("in->frameData = %p\n", in->frameData);
+ debug_msg("in->frameHeight = %d\n", in->frameHeight);
+ debug_msg("in->frameWidth = %d\n", in->frameWidth);
+ debug_msg("in->frameSize = %d\n", in->frameSize);
+ debug_msg("in->configLenth = %d\n", in->configLenth);
+ debug_msg("in->configData = %p\n", in->configData);
}
}
EXPORT_API
-void mmfile_codec_print (MMFileCodecContext *in)
+void mmfile_codec_print(MMFileCodecContext *in)
{
if (in) {
- debug_msg ("codecType = %d\n", in->codecType);
- debug_msg ("codec id = %d\n", in->codecId);
+ debug_msg("codecType = %d\n", in->codecType);
+ debug_msg("codec id = %d\n", in->codecId);
}
}
#ifdef __MMFILE_MEM_TRACE__
EXPORT_API
-int mmfile_util_wstrlen (unsigned short *wText)
+int mmfile_util_wstrlen(unsigned short *wText)
{
- int n = 0;
+ int n = 0;
- if (NULL == wText)
- {
- debug_error ("wText is NULL\n");
- return MMFILE_UTIL_FAIL;
- }
+ if (NULL == wText) {
+ debug_error("wText is NULL\n");
+ return MMFILE_UTIL_FAIL;
+ }
- n = 0;
+ n = 0;
- while ( *(wText+n) != 0 )
- {
- n++;
- }
+ while (*(wText + n) != 0) {
+ n++;
+ }
- return n;
+ return n;
}
-short __WmLngSwapShort( short aShort )
+short __WmLngSwapShort(short aShort)
{
- return ( ( aShort << 8 ) + ( aShort >> 8 ) );
+ return ((aShort << 8) + (aShort >> 8));
}
EXPORT_API
-short* mmfile_swap_2byte_string (short* mszOutput, short* mszInput, int length)
+short *mmfile_swap_2byte_string(short *mszOutput, short *mszInput, int length)
{
int i;
- for ( i = 0; i < length; i++ )
- {
- if ( mszInput[i] == 0 )
+ for (i = 0; i < length; i++) {
+ if (mszInput[i] == 0)
break;
- mszOutput[i] = __WmLngSwapShort( mszInput[i] );
+ mszOutput[i] = __WmLngSwapShort(mszInput[i]);
}
mszOutput[i] = 0;
EXPORT_API
-char *mmfile_string_convert_debug (const char *str, unsigned int len,
- const char *to_codeset, const char *from_codeset,
- int *bytes_read,
- int *bytes_written,
- const char *func,
- unsigned int line)
+char *mmfile_string_convert_debug(const char *str, unsigned int len,
+ const char *to_codeset, const char *from_codeset,
+ int *bytes_read,
+ int *bytes_written,
+ const char *func,
+ unsigned int line)
{
- char *tmp = g_convert (str, len, to_codeset, from_codeset, bytes_read, bytes_written, NULL);
+ char *tmp = g_convert(str, len, to_codeset, from_codeset, bytes_read, bytes_written, NULL);
- if (tmp)
- {
+ if (tmp) {
#ifdef __MMFILE_TEST_MODE__
debug_msg("## DEBUG ## %p = g_convert (%p, %u, %p, %p, %p ,%p, %p, %u) by %s() %d\n",
- tmp, str, len, to_codeset, from_codeset, bytes_read, bytes_written, func, line);
+ tmp, str, len, to_codeset, from_codeset, bytes_read, bytes_written, func, line);
#endif
- }
+ }
+
+ return tmp;
- return tmp;
-
}
EXPORT_API
-char **mmfile_strsplit (const char *string, const char *delimiter)
+char **mmfile_strsplit(const char *string, const char *delimiter)
{
- return g_strsplit (string, delimiter, -1);
+ return g_strsplit(string, delimiter, -1);
}
EXPORT_API
-void mmfile_strfreev (char **str_array)
+void mmfile_strfreev(char **str_array)
{
- g_strfreev(str_array);
+ g_strfreev(str_array);
}
EXPORT_API
-char *mmfile_strdup_debug (const char *str, const char *func, unsigned int line)
+char *mmfile_strdup_debug(const char *str, const char *func, unsigned int line)
{
- char *temp = NULL;
-
- if (!str)
- return NULL;
-
- temp = strdup (str);
-
- if (temp) {
+ char *temp = NULL;
+
+ if (!str)
+ return NULL;
+
+ temp = strdup(str);
+
+ if (temp) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## %p = strdup (%p) by %s() %d\n", temp, str, func, line);
+ debug_msg("## DEBUG ## %p = strdup (%p) by %s() %d\n", temp, str, func, line);
#endif
- }
+ }
- return temp;
+ return temp;
}
#else /* __MMFILE_MEM_TRACE__ */
EXPORT_API
-int mmfile_util_wstrlen (unsigned short *wText)
+int mmfile_util_wstrlen(unsigned short *wText)
{
- int n = 0;
+ int n = 0;
- if (NULL == wText)
- {
- debug_error ("wText is NULL\n");
- return MMFILE_UTIL_FAIL;
- }
+ if (NULL == wText) {
+ debug_error("wText is NULL\n");
+ return MMFILE_UTIL_FAIL;
+ }
- n = 0;
+ n = 0;
- while ( *(wText+n) != 0 )
- {
- n++;
- }
+ while (*(wText + n) != 0) {
+ n++;
+ }
- return n;
+ return n;
}
EXPORT_API
char *mmfile_get_charset(const char *str)
{
- UCharsetDetector* ucsd = NULL;
- const UCharsetMatch* ucm = NULL;
+ UCharsetDetector *ucsd = NULL;
+ const UCharsetMatch *ucm = NULL;
UErrorCode status = U_ZERO_ERROR;
- const char* charset = NULL;
+ const char *charset = NULL;
char *ret_charset = NULL;
- ucsd = ucsdet_open( &status );
- if( U_FAILURE(status) ) {
+ ucsd = ucsdet_open(&status);
+ if (U_FAILURE(status)) {
debug_error("fail to ucsdet_open\n");
return NULL;
}
- ucsdet_enableInputFilter( ucsd, TRUE );
+ ucsdet_enableInputFilter(ucsd, TRUE);
- ucsdet_setText( ucsd, str, strlen(str), &status );
- if( U_FAILURE(status) ) {
+ ucsdet_setText(ucsd, str, strlen(str), &status);
+ if (U_FAILURE(status)) {
debug_error("fail to ucsdet_setText\n");
goto done;
}
- ucm = ucsdet_detect( ucsd, &status );
- if( U_FAILURE(status) ) {
+ ucm = ucsdet_detect(ucsd, &status);
+ if (U_FAILURE(status)) {
debug_error("fail to ucsdet_detect\n");
goto done;
}
goto done;
}
- charset = ucsdet_getName( ucm, &status );
- if( U_FAILURE(status) ) {
+ charset = ucsdet_getName(ucm, &status);
+ if (U_FAILURE(status)) {
debug_error("fail to ucsdet_getName\n");
charset = NULL;
goto done;
if (charset != NULL)
ret_charset = strdup(charset);
- ucsdet_close( ucsd );
+ ucsdet_close(ucsd);
return ret_charset;
}
EXPORT_API
-char *mmfile_string_convert (const char *str, unsigned int len,
- const char *to_codeset, const char *from_codeset,
- unsigned int *bytes_read,
- unsigned int *bytes_written)
+char *mmfile_string_convert(const char *str, unsigned int len,
+ const char *to_codeset, const char *from_codeset,
+ unsigned int *bytes_read,
+ unsigned int *bytes_written)
{
char *result = NULL;
GError *err = NULL;
- int i = 0;
+ /*int i = 0;*/
unsigned int written_len = 0;
if (len != 0) {
- result = g_convert (str, len, to_codeset, from_codeset, bytes_read, &written_len, &err);
+ result = g_convert(str, len, to_codeset, from_codeset, bytes_read, &written_len, &err);
/*if converting failed, return duplicated source string.*/
if (result == NULL) {
#ifdef __MMFILE_TEST_MODE__
- debug_warning ("text encoding failed.[%s][%d]\n", str, len);
- if(err != NULL) {
- debug_warning ("Error msg [%s]", err->message);
+ debug_warning("text encoding failed.[%s][%d]\n", str, len);
+ if (err != NULL) {
+ debug_warning("Error msg [%s]", err->message);
g_error_free(err);
}
#endif
written_len = 0;
} else {
/* check carrige return */
- int i = 0;
+ unsigned int i = 0;
for (i = 0; i < written_len; i++) {
- if (result[i] == 13){
- if (result[i+1] != 10)
+ if (result[i] == 13) {
+ if (result[i + 1] != 10)
result[i] = 10;
}
}
written_len = 0;
}
- if(bytes_written != NULL) {
+ if (bytes_written != NULL) {
*bytes_written = written_len;
}
}
EXPORT_API
-char **mmfile_strsplit (const char *string, const char *delimiter)
+char **mmfile_strsplit(const char *string, const char *delimiter)
{
- return g_strsplit (string, delimiter, -1);
+ return g_strsplit(string, delimiter, -1);
}
EXPORT_API
-void mmfile_strfreev (char **str_array)
+void mmfile_strfreev(char **str_array)
{
- g_strfreev(str_array);
+ g_strfreev(str_array);
}
EXPORT_API
-char *mmfile_strdup (const char *str)
+char *mmfile_strdup(const char *str)
{
- if (!str)
- return NULL;
-
- return strdup (str);
+ if (!str)
+ return NULL;
+
+ return strdup(str);
}
#endif /*__MMFILE_MEM_TRACE__*/
#include <stdlib.h>
#include <ctype.h>
#include <vconf.h>
+#include <glib.h>
#include "mm_file_debug.h"
#include "mm_file_utils.h"
-#define ENABLE_ITUNES_META //All itunes metadata extracted by ffmpeg. see mov_read_udta_string() but Some cover art not support.
+#define ENABLE_ITUNES_META /*All itunes metadata extracted by ffmpeg. see mov_read_udta_string() but Some cover art not support. */
typedef struct _mmfilemp4basicboxheader {
unsigned int size;
#define MMFILE_SYNC_LYRIC_INFO_MIN_LEN 5
-#define FOURCC(a,b,c,d) ((a) + ((b) << 8) + ((c) << 16) + ((d) << 24))
+#define FOURCC(a, b, c, d) ((a) + ((b) << 8) + ((c) << 16) + ((d) << 24))
-#define MIN(a,b) (((a)<(b))?(a):(b))
+/*#define MIN(a, b) (((a) < (b)) ? (a):(b))*/
#define GENRE_COUNT 149
-static const char* MpegAudio_Genre[GENRE_COUNT] = {"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal",
-"New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial",
-"Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk",
-"Fusion", "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise",
-"AlternRock", "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
-"Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta",
-"Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave", "Showtunes",
-"Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
-"Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob", "Latin", "Revival", "Celtic", "Bluegrass",
-"Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic",
-"Humour", "Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus", "Porn Groove",
-"Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
-"Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall", "Goa", "Drum & Bass", "Club-House", "Hardcore",
-"Terror", "Indie", "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian", "Heavy Metal", "Black Metal", "Crossover",
-"Contemporary", "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "JPop", "Synthpop", "Unknown" };
-
-
-static int GetStringFromTextTagBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header, eMMFILE_3GP_TEXT_TAG eTag)
+static const char *MpegAudio_Genre[GENRE_COUNT] = {"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal",
+ "New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial",
+ "Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk",
+ "Fusion", "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise",
+ "AlternRock", "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
+ "Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta",
+ "Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave", "Showtunes",
+ "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
+ "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob", "Latin", "Revival", "Celtic", "Bluegrass",
+ "Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic",
+ "Humour", "Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus", "Porn Groove",
+ "Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
+ "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall", "Goa", "Drum & Bass", "Club-House", "Hardcore",
+ "Terror", "Indie", "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian", "Heavy Metal", "Black Metal", "Crossover",
+ "Contemporary", "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "JPop", "Synthpop", "Unknown"
+ };
+
+
+static int GetStringFromTextTagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header, eMMFILE_3GP_TEXT_TAG eTag)
{
int ret = MMFILE_UTIL_FAIL; /*fail*/
- MMFILE_3GP_TEXT_TAGBOX texttag = {0,};
+ MMFILE_3GP_TEXT_TAGBOX texttag = {0, };
int readed = 0;
int textBytes = 0;
char *temp_text = NULL;
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
textBytes = basic_header->size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_TEXT_TAGBOX_LEN;
- readed = mmfile_read (fp, (unsigned char *)&texttag, MMFILE_3GP_TEXT_TAGBOX_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&texttag, MMFILE_3GP_TEXT_TAGBOX_LEN);
if (readed != MMFILE_3GP_TEXT_TAGBOX_LEN) {
- debug_error ("read text tag header fail\n");
+ debug_error("read text tag header fail\n");
ret = MMFILE_UTIL_FAIL;
goto exception;
}
- if (textBytes <= 1) /* there exist only 00 (null) */
- {
- debug_error ("Text is NULL\n");
+ if (textBytes <= 1) { /* there exist only 00(null) */
+ debug_error("Text is NULL\n");
goto exception;
}
- texttag.text = mmfile_malloc (textBytes);
+ texttag.text = mmfile_malloc(textBytes);
if (!texttag.text) {
- debug_error ("malloc fail for text box\n");
+ debug_error("malloc fail for text box\n");
ret = MMFILE_UTIL_FAIL;
goto exception;
}
- readed = mmfile_read (fp, (unsigned char *)texttag.text, textBytes);
+ readed = mmfile_read(fp, (unsigned char *)texttag.text, textBytes);
if (readed != textBytes) {
- debug_error ("read text fail\n");
+ debug_error("read text fail\n");
ret = MMFILE_UTIL_FAIL;
goto exception;
}
/* check BOM char */
- if ( (texttag.text[0] == 0xFE) && (texttag.text[1] == 0xFF)) {
+ if ((texttag.text[0] == 0xFE) && (texttag.text[1] == 0xFF)) {
/* this char is UTF-16 */
unsigned int bytes_written = 0;
- temp_text = mmfile_string_convert ((const char *)&texttag.text[2], readed-2, "UTF-8", "UTF-16",NULL, (unsigned int*)&bytes_written);
+ temp_text = mmfile_string_convert((const char *)&texttag.text[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup ((const char *)texttag.text);
+ temp_text = mmfile_strdup((const char *)texttag.text);
}
switch (eTag) {
case eMMFILE_3GP_TAG_TITLE: {
- if (!formatContext->title) {
- formatContext->title = temp_text;
+ if (!formatContext->title) {
+ formatContext->title = temp_text;
+ }
+ break;
}
- break;
- }
case eMMFILE_3GP_TAG_CAPTION: {
- if (!formatContext->description) {
- formatContext->description = temp_text;
+ if (!formatContext->description) {
+ formatContext->description = temp_text;
+ }
+ break;
}
- break;
- }
case eMMFILE_3GP_TAG_COPYRIGHT: {
- if (!formatContext->copyright) {
- formatContext->copyright = temp_text;
+ if (!formatContext->copyright) {
+ formatContext->copyright = temp_text;
+ }
+ break;
}
- break;
- }
case eMMFILE_3GP_TAG_PERFORMER: {
- if (!formatContext->artist) {
- formatContext->artist = temp_text;
+ if (!formatContext->artist) {
+ formatContext->artist = temp_text;
+ }
+ break;
}
- break;
- }
case eMMFILE_3GP_TAG_AUTHOR: {
- if (!formatContext->author) {
- formatContext->author = temp_text;
+ if (!formatContext->author) {
+ formatContext->author = temp_text;
+ }
+ break;
}
- break;
- }
case eMMFILE_3GP_TAG_GENRE: {
- if (!formatContext->genre) {
- formatContext->genre = temp_text;
+ if (!formatContext->genre) {
+ formatContext->genre = temp_text;
+ }
+ break;
}
- break;
- }
default: {
- debug_warning("Not supported Text Tag type[%d]\n", eTag);
- break;
- }
+ debug_warning("Not supported Text Tag type[%d]\n", eTag);
+ break;
+ }
}
- mmfile_free (texttag.text);
+ mmfile_free(texttag.text);
texttag.text = NULL;
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
if (texttag.text) {
mmfile_free(texttag.text);
}
return ret;
}
-static int GetYearFromYearTagBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
+static int GetYearFromYearTagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
#define MAX_YEAR_BUFFER 10
int readed = 0;
- MMFILE_3GP_YEAR_TAGBOX yearbox = {0,};
- char temp_year[MAX_YEAR_BUFFER] = {0,};
+ MMFILE_3GP_YEAR_TAGBOX yearbox = {0, };
+ char temp_year[MAX_YEAR_BUFFER] = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&yearbox, MMFILE_3GP_YEAR_TAGBOX_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&yearbox, MMFILE_3GP_YEAR_TAGBOX_LEN);
if (readed != MMFILE_3GP_YEAR_TAGBOX_LEN) {
- debug_error ("read yeartag header fail\n");
+ debug_error("read yeartag header fail\n");
goto exception;
}
if (!formatContext->year) {
- yearbox.year = mmfile_io_be_int16 (yearbox.year);
- snprintf (temp_year, MAX_YEAR_BUFFER, "%d", yearbox.year);
- temp_year[MAX_YEAR_BUFFER-1] = '\0';
- formatContext->year = mmfile_strdup ((const char*)temp_year);
+ yearbox.year = mmfile_io_be_int16(yearbox.year);
+ snprintf(temp_year, MAX_YEAR_BUFFER, "%d", yearbox.year);
+ temp_year[MAX_YEAR_BUFFER - 1] = '\0';
+ formatContext->year = mmfile_strdup((const char *)temp_year);
}
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_FAIL;
}
-static int GetAlbumFromAlbumTagBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
+static int GetAlbumFromAlbumTagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
int albumTitleLen = 0;
char *temp_text = NULL;
int readed = 0;
int trackFlags = 0;
- MMFILE_3GP_ALBUM_TAGBOX albumbox = {0,};
+ MMFILE_3GP_ALBUM_TAGBOX albumbox = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&albumbox, MMFILE_3GP_ALBUM_TAGBOX_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&albumbox, MMFILE_3GP_ALBUM_TAGBOX_LEN);
if (readed != MMFILE_3GP_ALBUM_TAGBOX_LEN) {
- debug_error ("read albumtag header fail\n");
+ debug_error("read albumtag header fail\n");
goto exception;
}
albumTitleLen = basic_header->size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_ALBUM_TAGBOX_LEN - 1; /* 1: track number */
- if (albumTitleLen > 1) /* there exist only 00 (null) */
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("albumTitleLen=%d\n", albumTitleLen);
- #endif
+ if (albumTitleLen > 1) { /* there exist only 00(null) */
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("albumTitleLen=%d\n", albumTitleLen);
+#endif
- albumbox.albumtile = mmfile_malloc (albumTitleLen + 1); /* 1: for null char */
+ albumbox.albumtile = mmfile_malloc(albumTitleLen + 1); /* 1: for null char */
if (!albumbox.albumtile) {
- debug_error ("malloc fail for album title text\n");
+ debug_error("malloc fail for album title text\n");
goto exception;
}
- readed = mmfile_read (fp, (unsigned char *)albumbox.albumtile, albumTitleLen);
+ readed = mmfile_read(fp, (unsigned char *)albumbox.albumtile, albumTitleLen);
if (readed != albumTitleLen) {
- debug_error ("read album title fail\n");
+ debug_error("read album title fail\n");
goto exception;
}
- if (albumbox.albumtile[albumTitleLen-1] == '\0') /* there exist track number */
- {
+ if (albumbox.albumtile[albumTitleLen - 1] == '\0') { /* there exist track number */
trackFlags = 1;
- }
- else
- {
+ } else {
trackFlags = 0;
- readed = mmfile_read (fp, (unsigned char *)&(albumbox.albumtile[albumTitleLen]), 1);
+ readed = mmfile_read(fp, (unsigned char *)&(albumbox.albumtile[albumTitleLen]), 1);
if (readed != 1) {
- debug_error ("read album title fail\n");
+ debug_error("read album title fail\n");
goto exception;
- }
+ }
albumbox.albumtile[albumTitleLen] = '\0';
}
/* check BOM char */
- if ( (albumbox.albumtile[0] == 0xFE) && (albumbox.albumtile[1] == 0xFF)) {
+ if ((albumbox.albumtile[0] == 0xFE) && (albumbox.albumtile[1] == 0xFF)) {
/* this char is UTF-16 */
unsigned int bytes_written = 0;
- temp_text = mmfile_string_convert ((const char*)&albumbox.albumtile[2], readed-2, "UTF-8", "UTF-16", NULL, (unsigned int*)&bytes_written);
+ temp_text = mmfile_string_convert((const char *)&albumbox.albumtile[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup ((const char*)albumbox.albumtile);
+ temp_text = mmfile_strdup((const char *)albumbox.albumtile);
}
if (!formatContext->album) {
formatContext->album = temp_text;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("formatContext->album=%s, strlen=%d\n", formatContext->album, strlen(formatContext->album));
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("formatContext->album=%s, strlen=%d\n", formatContext->album, strlen(formatContext->album));
+#endif
}
if (trackFlags) {
- readed = mmfile_read (fp, (unsigned char *)&albumbox.trackNumber, 1);
+ readed = mmfile_read(fp, (unsigned char *)&albumbox.trackNumber, 1);
if (readed != 1) {
- debug_error ("read track number fail\n");
+ debug_error("read track number fail\n");
goto exception;
}
if (formatContext->tagTrackNum == 0) {
- char tracknum[10] = {0,};
- snprintf (tracknum, 10, "%d", albumbox.trackNumber);
+ char tracknum[10] = {0, };
+ snprintf(tracknum, 10, "%d", albumbox.trackNumber);
tracknum[9] = '\0';
- formatContext->tagTrackNum = mmfile_strdup ((const char*)tracknum);
+ formatContext->tagTrackNum = mmfile_strdup((const char *)tracknum);
}
}
- mmfile_free (albumbox.albumtile);
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(albumbox.albumtile);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
- mmfile_free (albumbox.albumtile);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(albumbox.albumtile);
return MMFILE_UTIL_FAIL;
}
-static int GetRatingFromRatingTagBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
+static int GetRatingFromRatingTagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
int readed = 0;
int ratinginfoLen = 0;
char *temp_text = NULL;
- MMFILE_3GP_RATING_TAGBOX ratingTag = {0,};
+ MMFILE_3GP_RATING_TAGBOX ratingTag = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&ratingTag, MMFILE_3GP_RATING_TAGBOX_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&ratingTag, MMFILE_3GP_RATING_TAGBOX_LEN);
if (readed != MMFILE_3GP_RATING_TAGBOX_LEN) {
- debug_error ("read rating tag header fail\n");
+ debug_error("read rating tag header fail\n");
goto exception;
}
ratinginfoLen = basic_header->size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_RATING_TAGBOX_LEN;
if (ratinginfoLen == 1) {
- debug_error ("Rating Text is NULL\n");
+ debug_error("Rating Text is NULL\n");
goto exception;
}
- ratingTag.ratingInfo = mmfile_malloc (ratinginfoLen);
+ ratingTag.ratingInfo = mmfile_malloc(ratinginfoLen);
if (!ratingTag.ratingInfo) {
- debug_error ("rating info error\n");
+ debug_error("rating info error\n");
goto exception;
}
- readed = mmfile_read (fp, (unsigned char *)ratingTag.ratingInfo, ratinginfoLen);
+ readed = mmfile_read(fp, (unsigned char *)ratingTag.ratingInfo, ratinginfoLen);
if (readed != ratinginfoLen) {
- debug_error ("read rating info string fail\n");
+ debug_error("read rating info string fail\n");
goto exception;
}
/* check BOM char */
- if ( (ratingTag.ratingInfo[0] == 0xFE) && (ratingTag.ratingInfo[1] == 0xFF)) {
+ if ((ratingTag.ratingInfo[0] == 0xFE) && (ratingTag.ratingInfo[1] == 0xFF)) {
/* this char is UTF-16 */
unsigned int bytes_written = 0;
- temp_text = mmfile_string_convert ((const char*)&ratingTag.ratingInfo[2], readed-2, "UTF-8", "UTF-16", NULL, (unsigned int*)&bytes_written);
+ temp_text = mmfile_string_convert((const char *)&ratingTag.ratingInfo[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup ((const char*)ratingTag.ratingInfo);
+ temp_text = mmfile_strdup((const char *)ratingTag.ratingInfo);
}
if (!formatContext->rating) {
formatContext->rating = temp_text;
} else {
- mmfile_free (temp_text);
+ mmfile_free(temp_text);
}
- mmfile_free (ratingTag.ratingInfo);
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(ratingTag.ratingInfo);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
- mmfile_free (ratingTag.ratingInfo);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(ratingTag.ratingInfo);
return MMFILE_UTIL_FAIL;
}
-static int GetClassficationFromClsfTagBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
+static int GetClassficationFromClsfTagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
int classinfoLen = 0;
int readed = 0;
char *temp_text = NULL;
- MMFILE_3GP_CLASSIFICATION_TAGBOX classTag = {0,};
+ MMFILE_3GP_CLASSIFICATION_TAGBOX classTag = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&classTag, MMFILE_3GP_CLASS_TAGBOX_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&classTag, MMFILE_3GP_CLASS_TAGBOX_LEN);
if (readed != MMFILE_3GP_CLASS_TAGBOX_LEN) {
- debug_error ("read classification tag header fail\n");
+ debug_error("read classification tag header fail\n");
goto exception;
}
classinfoLen = basic_header->size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_CLASS_TAGBOX_LEN;
if (classinfoLen == 1) {
- debug_error ("Classification Text is NULL\n");
+ debug_error("Classification Text is NULL\n");
goto exception;
}
- classTag.classificationInfo = mmfile_malloc (classinfoLen);
+ classTag.classificationInfo = mmfile_malloc(classinfoLen);
if (!classTag.classificationInfo) {
- debug_error ("class info error\n");
+ debug_error("class info error\n");
goto exception;
}
- readed = mmfile_read (fp, (unsigned char *)classTag.classificationInfo, classinfoLen);
+ readed = mmfile_read(fp, (unsigned char *)classTag.classificationInfo, classinfoLen);
if (readed != classinfoLen) {
- debug_error ("read class info string fail\n");
+ debug_error("read class info string fail\n");
goto exception;
}
/* check BOM char */
- if ( (classTag.classificationInfo[0] == 0xFE) && (classTag.classificationInfo[1] == 0xFF)) {
+ if ((classTag.classificationInfo[0] == 0xFE) && (classTag.classificationInfo[1] == 0xFF)) {
/* this char is UTF-16 */
unsigned int bytes_written = 0;
- temp_text = mmfile_string_convert ((const char*)&classTag.classificationInfo[2], readed-2, "UTF-8", "UTF-16", NULL, (unsigned int*)&bytes_written);
+ temp_text = mmfile_string_convert((const char *)&classTag.classificationInfo[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup ((const char*)classTag.classificationInfo);
+ temp_text = mmfile_strdup((const char *)classTag.classificationInfo);
}
if (!formatContext->classification) {
formatContext->classification = temp_text;
} else {
- mmfile_free (temp_text);
+ mmfile_free(temp_text);
}
- mmfile_free (classTag.classificationInfo);
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(classTag.classificationInfo);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
- mmfile_free (classTag.classificationInfo);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(classTag.classificationInfo);
return MMFILE_UTIL_FAIL;
}
* information
* --------------------+-------------------+-----------------------------------+------
*/
-static int _get_char_position (unsigned char *src, char ch, int max)
+static int _get_char_position(unsigned char *src, char ch, int max)
{
int i;
for (i = 0; i < max; i++) {
- if ( *(src + i) == ch)
+ if (*(src + i) == ch)
return i;
}
return -1;
-}
-
-static int GetLocationFromLociTagBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
+}
+
+static int GetLocationFromLociTagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
- MMFILE_3GP_LOCATION_TAGBOX lociTag = {0,};
+ MMFILE_3GP_LOCATION_TAGBOX lociTag = {0, };
int readed = 0;
int bufferLen = 0;
unsigned char *buffer = NULL;
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&lociTag, 6); /*6 = version + flag + pad + language */
+ readed = mmfile_read(fp, (unsigned char *)&lociTag, 6); /*6 = version + flag + pad + language */
if (readed != 6) {
- debug_error ("read location tag header fail\n");
+ debug_error("read location tag header fail\n");
goto exception;
}
/*buffer len = name + role + ... + additional notes length */
bufferLen = basic_header->size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - 6;
if (bufferLen < 1) {
- debug_error ("too small buffer\n");
+ debug_error("too small buffer\n");
goto exception;
}
- buffer = mmfile_malloc (bufferLen);
+ buffer = mmfile_malloc(bufferLen);
if (!buffer) {
- debug_error ("buffer malloc error\n");
+ debug_error("buffer malloc error\n");
goto exception;
}
- readed = mmfile_read (fp, (unsigned char *)buffer, bufferLen);
+ readed = mmfile_read(fp, (unsigned char *)buffer, bufferLen);
if (readed != bufferLen) {
- debug_error ("read location tag fail\n");
+ debug_error("read location tag fail\n");
goto exception;
}
p = buffer;
/*name*/
- pos = _get_char_position (p, '\0', readed - (1+4+4+4+2));
+ pos = _get_char_position(p, '\0', readed - (1 + 4 + 4 + 4 + 2));
if (pos >= 0) {
if (p[0] == 0xFE && p[1] == 0xFF) {
- lociTag.name = (unsigned char*)mmfile_string_convert ((const char*)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int*)&bytes_written);
+ lociTag.name = (unsigned char *)mmfile_string_convert((const char *)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- lociTag.name = (unsigned char*)mmfile_strdup ((const char*)p);
+ lociTag.name = (unsigned char *)mmfile_strdup((const char *)p);
}
} else {
goto exception;
lociTag.role = *p;
p++;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("long: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p+0), *(p+1), *(p+2), *(p+3));
- debug_msg ("lati: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p+4), *(p+5), *(p+6), *(p+7));
- debug_msg ("alti: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p+8), *(p+9), *(p+10), *(p+11));
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("long: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p + 0), *(p + 1), *(p + 2), *(p + 3));
+ debug_msg("lati: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p + 4), *(p + 5), *(p + 6), *(p + 7));
+ debug_msg("alti: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p + 8), *(p + 9), *(p + 10), *(p + 11));
+#endif
- ilong = mmfile_io_be_uint32 (*(unsigned int*)p);
- ilati = mmfile_io_be_uint32 (*(unsigned int*)(p+4));
- ialti = mmfile_io_be_uint32 (*(unsigned int*)(p+8));
+ ilong = mmfile_io_be_uint32(*(unsigned int *)p);
+ ilati = mmfile_io_be_uint32(*(unsigned int *)(p + 4));
+ ialti = mmfile_io_be_uint32(*(unsigned int *)(p + 8));
- flong = (float)ilong / (1<<16);
- flati = (float)ilati / (1<<16);
- falti = (float)ialti / (1<<16);
+ flong = (float)ilong / (1 << 16);
+ flati = (float)ilati / (1 << 16);
+ falti = (float)ialti / (1 << 16);
/*longitude*/
lociTag.longitude = flong;
lociTag.latitude = flati;
/*altitude*/
lociTag.altitude = falti;
-
+
p += 12;
/*astronomical body*/
- pos = _get_char_position (p, '\0', readed - (name_sz+1+4+4+4+1));
+ pos = _get_char_position(p, '\0', readed - (name_sz + 1 + 4 + 4 + 4 + 1));
if (pos >= 0) {
if (p[0] == 0xFE && p[1] == 0xFF) {
- lociTag.astronomical_body = (unsigned char*)mmfile_string_convert ((const char*)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int*)&bytes_written);
+ lociTag.astronomical_body = (unsigned char *)mmfile_string_convert((const char *)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- lociTag.astronomical_body = (unsigned char*)mmfile_strdup ((const char*)p);
+ lociTag.astronomical_body = (unsigned char *)mmfile_strdup((const char *)p);
}
} else {
goto exception;
p += (pos + 1);
/*additional notes*/
- pos = _get_char_position (p, '\0', readed - (name_sz+1+4+4+4+astro_sz));
+ pos = _get_char_position(p, '\0', readed - (name_sz + 1 + 4 + 4 + 4 + astro_sz));
if (pos >= 0) {
if (p[0] == 0xFE && p[1] == 0xFF) {
- lociTag.additional_notes = (unsigned char*)mmfile_string_convert ((const char*)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int*)&bytes_written);
+ lociTag.additional_notes = (unsigned char *)mmfile_string_convert((const char *)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- lociTag.additional_notes = (unsigned char*)mmfile_strdup ((const char*)p);
+ lociTag.additional_notes = (unsigned char *)mmfile_strdup((const char *)p);
}
} else {
goto exception;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("** Location Information **\n");
- debug_msg ("Name : %s\n", lociTag.name);
- debug_msg ("Role : %d (0: shooting, 1: real, 2: fictional, other: reserved)\n", lociTag.role);
- debug_msg ("Longitude : %16.16f\n", lociTag.longitude);
- debug_msg ("Latitude : %16.16f\n", lociTag.latitude);
- debug_msg ("Altitude : %16.16f\n", lociTag.altitude);
- debug_msg ("Astronomical body: %s\n", lociTag.astronomical_body);
- debug_msg ("Additional notes : %s\n", lociTag.additional_notes);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("** Location Information **\n");
+ debug_msg("Name : %s\n", lociTag.name);
+ debug_msg("Role : %d (0: shooting, 1: real, 2: fictional, other: reserved)\n", lociTag.role);
+ debug_msg("Longitude : %16.16f\n", lociTag.longitude);
+ debug_msg("Latitude : %16.16f\n", lociTag.latitude);
+ debug_msg("Altitude : %16.16f\n", lociTag.altitude);
+ debug_msg("Astronomical body: %s\n", lociTag.astronomical_body);
+ debug_msg("Additional notes : %s\n", lociTag.additional_notes);
+#endif
formatContext->longitude = lociTag.longitude;
formatContext->latitude = lociTag.latitude;
formatContext->altitude = lociTag.altitude;
- mmfile_free (buffer);
- mmfile_free (lociTag.name);
- mmfile_free (lociTag.astronomical_body);
- mmfile_free (lociTag.additional_notes);
+ mmfile_free(buffer);
+ mmfile_free(lociTag.name);
+ mmfile_free(lociTag.astronomical_body);
+ mmfile_free(lociTag.additional_notes);
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
-
+
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
- mmfile_free (buffer);
- mmfile_free (lociTag.name);
- mmfile_free (lociTag.astronomical_body);
- mmfile_free (lociTag.additional_notes);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(buffer);
+ mmfile_free(lociTag.name);
+ mmfile_free(lociTag.astronomical_body);
+ mmfile_free(lociTag.additional_notes);
return MMFILE_UTIL_FAIL;
}
static int GetSAUTInfoFromSMTATagBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
- MMFILE_M4A_SMTA_TAGBOX smtaTag = {0,};
+ MMFILE_M4A_SMTA_TAGBOX smtaTag = {0, };
int readed = 0;
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&smtaTag, sizeof(MMFILE_M4A_SMTA_TAGBOX));
+ readed = mmfile_read(fp, (unsigned char *)&smtaTag, sizeof(MMFILE_M4A_SMTA_TAGBOX));
if (readed != sizeof(MMFILE_M4A_SMTA_TAGBOX)) {
- debug_error ("read smta tag header fail\n");
+ debug_error("read smta tag header fail\n");
goto exception;
}
#endif
if (smtaTag.saut[0] == 's'
- && smtaTag.saut[1] == 'a'
- && smtaTag.saut[2] == 'u'
- && smtaTag.saut[3] == 't') {
+ && smtaTag.saut[1] == 'a'
+ && smtaTag.saut[2] == 'u'
+ && smtaTag.saut[3] == 't') {
if (smtaTag.value == 0x01) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("This has saut tag and valid value");
- #endif
+#endif
formatContext->smta = 1;
} else {
debug_error("This has saut tag and but invalid value");
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_FAIL;
}
int readed = 0;
if (!formatContext || !fp || !basic_header) {
- debug_error ("invalid param\n");
+ debug_error("invalid param\n");
return MMFILE_UTIL_FAIL;
}
- readed = mmfile_read (fp, (unsigned char *)&value, sizeof(unsigned int));
+ readed = mmfile_read(fp, (unsigned char *)&value, sizeof(unsigned int));
if (readed != sizeof(unsigned int)) {
- debug_error ("read cdis tag header fail\n");
+ debug_error("read cdis tag header fail\n");
goto exception;
}
#endif
if (value == 0x01) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("This has cdis tag and valid value");
- #endif
+#endif
formatContext->cdis = 1;
} else {
debug_error("This has cdis tag and but invalid value");
return MMFILE_UTIL_SUCCESS;
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_FAIL;
}
-static int GetTagFromMetaBox (MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
+static int GetTagFromMetaBox(MMFileFormatContext *formatContext, MMFileIOHandle *fp, MMFILE_MP4_BASIC_BOX_HEADER *basic_header)
{
int readed = 0;
- MMFILE_MP4_BASIC_BOX_HEADER hdlrBoxHeader = {0,};
- MMFILE_MP4_BASIC_BOX_HEADER id3v2BoxHeader = {0,};
- MMFILE_3GP_ID3V2_BOX id3v2Box = {0,};
- AvFileContentInfo tagInfo = {0,};
+ MMFILE_MP4_BASIC_BOX_HEADER hdlrBoxHeader = {0, };
+ MMFILE_MP4_BASIC_BOX_HEADER id3v2BoxHeader = {0, };
+ MMFILE_3GP_ID3V2_BOX id3v2Box = {0, };
+ AvFileContentInfo tagInfo = {0, };
unsigned char tagVersion = 0;
bool versionCheck = false;
int id3v2Len = 0;
unsigned int meta_version = 0;
- MMFILE_3GP_HANDLER_BOX hdlrBox = {0,};
- int encSize = 0;
+ MMFILE_3GP_HANDLER_BOX hdlrBox = {0, };
+ unsigned int encSize = 0;
int id3_meta = 0;
#ifdef ENABLE_ITUNES_META /* We don't support itunes meta now. so this is not defined yet */
int iTunes_meta = 0;
#endif
/* meta box */
- readed = mmfile_read (fp, (unsigned char *)&meta_version, 4);
+ readed = mmfile_read(fp, (unsigned char *)&meta_version, 4);
if (readed != 4) {
- debug_error ("read meta box version\n");
+ debug_error("read meta box version\n");
goto exception;
}
/* hdlr box */
- readed = mmfile_read (fp, (unsigned char *)&hdlrBoxHeader, MMFILE_MP4_BASIC_BOX_HEADER_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&hdlrBoxHeader, MMFILE_MP4_BASIC_BOX_HEADER_LEN);
if (readed != MMFILE_MP4_BASIC_BOX_HEADER_LEN) {
- debug_error ("read hdlr box header\n");
+ debug_error("read hdlr box header\n");
goto exception;
}
- if (hdlrBoxHeader.type != FOURCC ('h', 'd', 'l', 'r')) {
- debug_warning ("meta type is not hdlr\n");
+ if (hdlrBoxHeader.type != FOURCC('h', 'd', 'l', 'r')) {
+ debug_warning("meta type is not hdlr\n");
goto exception;
}
- hdlrBoxHeader.size = mmfile_io_be_uint32 (hdlrBoxHeader.size);
- hdlrBoxHeader.type = mmfile_io_le_uint32 (hdlrBoxHeader.type);
+ hdlrBoxHeader.size = mmfile_io_be_uint32(hdlrBoxHeader.size);
+ hdlrBoxHeader.type = mmfile_io_le_uint32(hdlrBoxHeader.type);
- readed = mmfile_read (fp, (unsigned char *)&hdlrBox, MMFILE_3GP_HANDLER_BOX_LEN);
+ readed = mmfile_read(fp, (unsigned char *)&hdlrBox, MMFILE_3GP_HANDLER_BOX_LEN);
if (readed != MMFILE_3GP_HANDLER_BOX_LEN) {
- debug_error ("read hdlr box\n");
+ debug_error("read hdlr box\n");
goto exception;
}
- hdlrBox.handler_type = mmfile_io_le_uint32 (hdlrBox.handler_type);
+ hdlrBox.handler_type = mmfile_io_le_uint32(hdlrBox.handler_type);
/**
* check tag type (ID3v2 or iTunes)
*/
- if (hdlrBox.handler_type == FOURCC ('I', 'D', '3', '2')) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("ID3v2 tag detected.\n");
- #endif
+ if (hdlrBox.handler_type == FOURCC('I', 'D', '3', '2')) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("ID3v2 tag detected.\n");
+#endif
id3_meta = 1;
#ifdef ENABLE_ITUNES_META
iTunes_meta = 0;
#endif
- } else if (hdlrBox.handler_type == FOURCC ('m', 'd', 'i', 'r') &&
- mmfile_io_le_uint32 (hdlrBox.reserved[0]) == FOURCC ('a', 'p', 'p', 'l')) {
+ } else if (hdlrBox.handler_type == FOURCC('m', 'd', 'i', 'r') &&
+ mmfile_io_le_uint32(hdlrBox.reserved[0]) == FOURCC('a', 'p', 'p', 'l')) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Apple iTunes tag detected by mdir.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Apple iTunes tag detected by mdir.\n");
+#endif
#ifdef ENABLE_ITUNES_META
iTunes_meta = 1;
#endif
} else {
- debug_warning ("unknown meta type. 4CC:[%c%c%c%c]\n", ((char*)&hdlrBox.handler_type)[0],
- ((char*)&hdlrBox.handler_type)[1],
- ((char*)&hdlrBox.handler_type)[2],
- ((char*)&hdlrBox.handler_type)[3]);
- //goto exception;
+ debug_warning("unknown meta type. 4CC:[%c%c%c%c]\n", ((char *)&hdlrBox.handler_type)[0],
+ ((char *)&hdlrBox.handler_type)[1],
+ ((char *)&hdlrBox.handler_type)[2],
+ ((char *)&hdlrBox.handler_type)[3]);
+ /*goto exception; */
}
#ifdef ENABLE_ITUNES_META
- if(!id3_meta && !iTunes_meta) {
+ if (!id3_meta && !iTunes_meta) {
/*Check ilst.
APPLE meta data for iTunes reader = 'mdir.' so if handler type is 'mdir', this content may has itunes meta.
most of contents has 'mdir' + 'appl'. but some contents just has 'mdir'
const char *ilst_box = "ilst";
int buf_size = strlen(ilst_box);
- unsigned char read_buf[buf_size+1];
- memset(read_buf, 0x00, buf_size+1);
+ unsigned char read_buf[buf_size + 1];
+ memset(read_buf, 0x00, buf_size + 1);
/* skip hdlr box */
- mmfile_seek (fp, hdlrBoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_HANDLER_BOX_LEN +4, SEEK_CUR); //+4 is hdlr size field
+ mmfile_seek(fp, hdlrBoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_HANDLER_BOX_LEN + 4, SEEK_CUR); /*+4 is hdlr size field */
- readed = mmfile_read (fp, read_buf, buf_size); // to find 'ilst'
+ readed = mmfile_read(fp, read_buf, buf_size); /* to find 'ilst' */
if (readed != buf_size) {
- debug_error ("read fail [%d]\n", readed);
+ debug_error("read fail [%d]\n", readed);
goto exception;
}
- if(read_buf[0] == 'i' && read_buf[1] == 'l' && read_buf[2] == 's' && read_buf[3] == 't') {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Apple iTunes tag detected by ilst.\n");
- #endif
+ if (read_buf[0] == 'i' && read_buf[1] == 'l' && read_buf[2] == 's' && read_buf[3] == 't') {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Apple iTunes tag detected by ilst.\n");
+#endif
iTunes_meta = 1;
}
unsigned char read_buf[_ITUNES_READ_BUF_SZ];
int i = 0;
int cover_sz = 0, cover_type = 0, cover_found = 0;
- //int track_found = 0; //, track_num = 0;
- //int genre_found = 0; //, genre_index = 0;
- //int artist_found = 0; //, artist_sz = 0;
+ /* int track_found = 0; */ /* , track_num = 0; */
+ /* int genre_found = 0; */ /* , genre_index = 0; */
+ /* int artist_found = 0; */ /* , artist_sz = 0; */
int limit = basic_header->size - hdlrBoxHeader.size;
- long long cover_offset = 0; //, track_offset =0 , genre_offset = 0, artist_offset = 0;
+ long long cover_offset = 0; /*, track_offset =0, genre_offset = 0, artist_offset = 0; */
-// for (i = 0, cover_found = 0, track_found = 0, genre_found = 0, artist_found = 0; i < limit && (cover_found == 0 || track_found == 0 || genre_found == 0 || artist_found == 0) ; i++) {
+ /* for (i = 0, cover_found = 0, track_found = 0, genre_found = 0, artist_found = 0; i < limit && (cover_found == 0 || track_found == 0 || genre_found == 0 || artist_found == 0) ; i++) { */
for (i = 0; (i < limit) && (cover_found == 0) ; i++) {
- readed = mmfile_read (fp, read_buf, _ITUNES_READ_BUF_SZ);
+ readed = mmfile_read(fp, read_buf, _ITUNES_READ_BUF_SZ);
if (readed != _ITUNES_READ_BUF_SZ)
goto exception;
-/*ffmpeg extract artist, tracknum, genre and cover image. see mov_read_udta_string().
-but ffmpeg does not support strange cover image.
-only support covr type 0xd(JPEG), 0xe(PNG), 0x1b(BMP). but we support other type*/
+ /*ffmpeg extract artist, tracknum, genre and cover image. see mov_read_udta_string().
+ but ffmpeg does not support strange cover image.
+ only support covr type 0xd(JPEG), 0xe(PNG), 0x1b(BMP). but we support other type*/
#if 0
/**
* Artist : Added 2010.10.28
*/
if (artist_found == 0 &&
- read_buf[0] == 0xa9 && read_buf[1] == 'A' && read_buf[2] == 'R' && read_buf[3] == 'T' &&
- read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
+ read_buf[0] == 0xa9 && read_buf[1] == 'A' && read_buf[2] == 'R' && read_buf[3] == 'T' &&
+ read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
artist_found = 1;
- artist_offset = mmfile_tell (fp);
- artist_sz = mmfile_io_be_uint32 (*(int*)(read_buf + 4)) - 16; /* atom len(4)+data(4)+atom verion(1)+flag(3)+null(4) = 16 */
+ artist_offset = mmfile_tell(fp);
+ artist_sz = mmfile_io_be_uint32(*(int *)(read_buf + 4)) - 16; /* atom len(4)+data(4)+atom verion(1)+flag(3)+null(4) = 16 */
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- artist found, offset=[%lld], size=[%d]\n", artist_offset, artist_sz);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- artist found, offset=[%lld], size=[%d]\n", artist_offset, artist_sz);
+#endif
}
/**
* Track number
*/
if (track_found == 0 &&
- read_buf[0] == 't' && read_buf[1] == 'r' && read_buf[2] == 'k' && read_buf[3] == 'n' &&
- read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
+ read_buf[0] == 't' && read_buf[1] == 'r' && read_buf[2] == 'k' && read_buf[3] == 'n' &&
+ read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
track_found = 1;
- track_offset = mmfile_tell (fp);
+ track_offset = mmfile_tell(fp);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- Track found, offset=[%lld]\n", track_offset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- Track found, offset=[%lld]\n", track_offset);
+#endif
}
/**
*/
/*ffmpeg extract genre but only (0xa9,'g','e','n'). see mov_read_udta_string()*/
if (genre_found == 0 &&
- read_buf[0] == 'g' && read_buf[1] == 'n' && read_buf[2] == 'r' && read_buf[3] == 'e' &&
- read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
+ read_buf[0] == 'g' && read_buf[1] == 'n' && read_buf[2] == 'r' && read_buf[3] == 'e' &&
+ read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
genre_found = 1;
- genre_offset = mmfile_tell (fp);
+ genre_offset = mmfile_tell(fp);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- genre found, offset=[%lld]\n", genre_offset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- genre found, offset=[%lld]\n", genre_offset);
+#endif
}
#endif
*/
if (cover_found == 0 &&
- read_buf[0] == 'c' && read_buf[1] == 'o' && read_buf[2] == 'v' && read_buf[3] == 'r' &&
- read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
+ read_buf[0] == 'c' && read_buf[1] == 'o' && read_buf[2] == 'v' && read_buf[3] == 'r' &&
+ read_buf[8] == 'd' && read_buf[9] == 'a' && read_buf[10] == 't' && read_buf[11] == 'a') {
cover_found = 1;
- cover_sz = mmfile_io_be_uint32 (*(int*)(read_buf + 4)) - 12;
- cover_type = mmfile_io_be_uint32 (*(int*)(read_buf + 12));
+ cover_sz = mmfile_io_be_uint32(*(int *)(read_buf + 4)) - 12;
+ cover_type = mmfile_io_be_uint32(*(int *)(read_buf + 12));
- cover_offset = mmfile_tell (fp);
+ cover_offset = mmfile_tell(fp);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- cover_found found, offset=[%lld]\n", cover_offset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- cover_found found, offset=[%lld]\n", cover_offset);
+#endif
}
- mmfile_seek (fp, -(_ITUNES_READ_BUF_SZ - 1), SEEK_CUR); /*FIXME: poor search*/
+ mmfile_seek(fp, -(_ITUNES_READ_BUF_SZ - 1), SEEK_CUR); /*FIXME: poor search*/
} /*loop*/
-/*ffmpeg extract artist, tracknum, excep cover image. see mov_read_udta_string()*/
+ /*ffmpeg extract artist, tracknum, excep cover image. see mov_read_udta_string()*/
#if 0
if (artist_found) {
if (artist_sz > 0) {
- mmfile_seek (fp, artist_offset, SEEK_SET);
+ mmfile_seek(fp, artist_offset, SEEK_SET);
if (formatContext->artist) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- previous artist was [%s] \n", formatContext->artist);
- #endif
- free (formatContext->artist);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- previous artist was [%s] \n", formatContext->artist);
+#endif
+ free(formatContext->artist);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- new artist will be allocated with size (len+1) [%d] \n", artist_sz+1);
- #endif
- formatContext->artist = mmfile_malloc (artist_sz+1);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- new artist will be allocated with size (len+1) [%d] \n", artist_sz + 1);
+#endif
+ formatContext->artist = mmfile_malloc(artist_sz + 1);
if (formatContext->artist) {
- readed = mmfile_read (fp, (unsigned char*)formatContext->artist, artist_sz);
+ readed = mmfile_read(fp, (unsigned char *)formatContext->artist, artist_sz);
formatContext->artist[artist_sz] = '\0';
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------- new artist is [%s] \n", formatContext->artist);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------- new artist is [%s] \n", formatContext->artist);
+#endif
if (readed != artist_sz) {
- debug_error ("failed to read. ret = %d, in = %d\n", readed, artist_sz);
- mmfile_free (formatContext->artist);
+ debug_error("failed to read. ret = %d, in = %d\n", readed, artist_sz);
+ mmfile_free(formatContext->artist);
}
}
}
}
if (track_found) {
- mmfile_seek (fp, track_offset, SEEK_SET);
- readed = mmfile_read (fp, read_buf, _ITUNES_TRACK_NUM_SZ);
+ mmfile_seek(fp, track_offset, SEEK_SET);
+ readed = mmfile_read(fp, read_buf, _ITUNES_TRACK_NUM_SZ);
if (readed != _ITUNES_TRACK_NUM_SZ) {
- debug_error ("failed to read. ret = %d, in = %d\n", readed, _ITUNES_TRACK_NUM_SZ);
+ debug_error("failed to read. ret = %d, in = %d\n", readed, _ITUNES_TRACK_NUM_SZ);
} else {
- track_num = mmfile_io_be_uint32 (*(int*)read_buf);
+ track_num = mmfile_io_be_uint32(*(int *)read_buf);
if (!formatContext->tagTrackNum) {
- memset (read_buf, 0x00, _ITUNES_READ_BUF_SZ);
- snprintf ((char*)read_buf, sizeof(read_buf), "%d", track_num);
- formatContext->tagTrackNum = mmfile_strdup ((const char*)read_buf);
+ memset(read_buf, 0x00, _ITUNES_READ_BUF_SZ);
+ snprintf((char *)read_buf, sizeof(read_buf), "%d", track_num);
+ formatContext->tagTrackNum = mmfile_strdup((const char *)read_buf);
}
}
}
if (genre_found) {
- mmfile_seek (fp, genre_offset, SEEK_SET);
- readed = mmfile_read (fp, read_buf, _ITUNES_GENRE_NUM_SZ);
+ mmfile_seek(fp, genre_offset, SEEK_SET);
+ readed = mmfile_read(fp, read_buf, _ITUNES_GENRE_NUM_SZ);
if (readed != _ITUNES_GENRE_NUM_SZ) {
- debug_error ("failed to read. ret = %d, in = %d\n", readed, _ITUNES_GENRE_NUM_SZ);
+ debug_error("failed to read. ret = %d, in = %d\n", readed, _ITUNES_GENRE_NUM_SZ);
} else {
- genre_index = mmfile_io_be_uint16 (*(int*)read_buf);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("genre index=[%d] \n", genre_index);
- #endif
+ genre_index = mmfile_io_be_uint16(*(int *)read_buf);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("genre index=[%d] \n", genre_index);
+#endif
if (genre_index > 0 && genre_index < GENRE_COUNT) {
if (!formatContext->genre) {
- memset (read_buf, 0x00, _ITUNES_READ_BUF_SZ);
- snprintf ((char*)read_buf, sizeof(read_buf),"%s", MpegAudio_Genre[genre_index-1]);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("genre string=[%s] \n", read_buf);
- #endif
- formatContext->genre = mmfile_strdup ((const char*)read_buf);
+ memset(read_buf, 0x00, _ITUNES_READ_BUF_SZ);
+ snprintf((char *)read_buf, sizeof(read_buf), "%s", MpegAudio_Genre[genre_index - 1]);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("genre string=[%s] \n", read_buf);
+#endif
+ formatContext->genre = mmfile_strdup((const char *)read_buf);
}
}
}
}
#endif
-/*
- 1) below spec is in "iTunes Package Asset Specification 4.3" published by apple.
- Music Cover Art Image Profile
- - TIFF with ".tif" extension (32-bit uncompressed), JPEG with ".jpg" extension (quality unconstrained), or PNG with ".png" extension
- - RGB (screen standard)
- - Minimum size of 600 x 600 pixels
- - Images must be at least 72 dpi
-
- 2)I found below info from google.
- cover image flag : JPEG (13, 0xd), PNG (14, 0xe)
-
- 3)So, FIXME when cover image format is tif!
-*/
+ /*
+ 1) below spec is in "iTunes Package Asset Specification 4.3" published by apple.
+ Music Cover Art Image Profile
+ - TIFF with ".tif" extension (32-bit uncompressed), JPEG with ".jpg" extension (quality unconstrained), or PNG with ".png" extension
+ - RGB (screen standard)
+ - Minimum size of 600 x 600 pixels
+ - Images must be at least 72 dpi
+
+ 2)I found below info from google.
+ cover image flag : JPEG (13, 0xd), PNG (14, 0xe)
+
+ 3)So, FIXME when cover image format is tif!
+ */
if (cover_found) {
if (cover_sz > 0) {
- mmfile_seek (fp, cover_offset, SEEK_SET);
+ mmfile_seek(fp, cover_offset, SEEK_SET);
- formatContext->artwork = mmfile_malloc (cover_sz);
+ formatContext->artwork = mmfile_malloc(cover_sz);
formatContext->artworkSize = cover_sz;
- if(cover_type == _ITUNES_COVER_TYPE_JPEG) {
+ if (cover_type == _ITUNES_COVER_TYPE_JPEG) {
formatContext->artworkMime = mmfile_strdup("image/jpeg");
- } else if(cover_type == _ITUNES_COVER_TYPE_PNG) {
+ } else if (cover_type == _ITUNES_COVER_TYPE_PNG) {
formatContext->artworkMime = mmfile_strdup("image/png");
- /*} else if(cover_type == _ITUNES_COVER_TYPE_TIF) {
- formatContext->artworkMime = mmfile_strdup("image/tif");*/
+ /*} else if(cover_type == _ITUNES_COVER_TYPE_TIF) {
+ formatContext->artworkMime = mmfile_strdup("image/tif");*/
} else {
debug_warning("Not proper cover image type, but set to jpeg. cover_type[%d]", cover_type);
formatContext->artworkMime = mmfile_strdup("image/jpeg");
}
if (formatContext->artwork) {
- readed = mmfile_read (fp, formatContext->artwork, cover_sz);
+ readed = mmfile_read(fp, formatContext->artwork, cover_sz);
if (readed != cover_sz) {
- debug_error ("failed to read. ret = %d, in = %d\n", readed, cover_sz);
- mmfile_free (formatContext->artwork);
+ debug_error("failed to read. ret = %d, in = %d\n", readed, cover_sz);
+ mmfile_free(formatContext->artwork);
formatContext->artworkSize = 0;
- mmfile_free (formatContext->artworkMime);
+ mmfile_free(formatContext->artworkMime);
}
}
}
}
/*reset seek position*/
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
return MMFILE_UTIL_SUCCESS;
} else
#endif
- if(id3_meta) {
- /**
- * ID3v2
- */
- /* skip hdlr box name */
- mmfile_seek (fp, hdlrBoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_HANDLER_BOX_LEN, SEEK_CUR);
-
- /* id3 tag box */
- readed = mmfile_read (fp, (unsigned char *)&id3v2BoxHeader, MMFILE_MP4_BASIC_BOX_HEADER_LEN);
- if (readed != MMFILE_MP4_BASIC_BOX_HEADER_LEN)
- {
- debug_error ("read id3v2 box header\n");
- goto exception;
- }
-
- id3v2BoxHeader.size = mmfile_io_be_uint32 (id3v2BoxHeader.size);
- id3v2BoxHeader.type = mmfile_io_le_uint32 (id3v2BoxHeader.type);
-
- if (id3v2BoxHeader.type != FOURCC ('I', 'D', '3', '2'))
- {
- debug_warning ("meta type is not id3v2\n");
- goto exception;
- }
+ if (id3_meta) {
+ /**
+ * ID3v2
+ */
+ /* skip hdlr box name */
+ mmfile_seek(fp, hdlrBoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_HANDLER_BOX_LEN, SEEK_CUR);
- readed = mmfile_read (fp, (unsigned char *)&id3v2Box, MMFILE_3GP_ID3V2_BOX_LEN);
- if (readed != MMFILE_3GP_ID3V2_BOX_LEN)
- {
- debug_error ("read id3v2 box\n");
- goto exception;
- }
+ /* id3 tag box */
+ readed = mmfile_read(fp, (unsigned char *)&id3v2BoxHeader, MMFILE_MP4_BASIC_BOX_HEADER_LEN);
+ if (readed != MMFILE_MP4_BASIC_BOX_HEADER_LEN) {
+ debug_error("read id3v2 box header\n");
+ goto exception;
+ }
- id3v2Len = id3v2BoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_ID3V2_BOX_LEN;
+ id3v2BoxHeader.size = mmfile_io_be_uint32(id3v2BoxHeader.size);
+ id3v2BoxHeader.type = mmfile_io_le_uint32(id3v2BoxHeader.type);
- id3v2Box.id3v2Data = mmfile_malloc (id3v2Len);
- if (!id3v2Box.id3v2Data)
- {
- debug_error ("malloc id3tag data error\n");
- goto exception;
- }
+ if (id3v2BoxHeader.type != FOURCC('I', 'D', '3', '2')) {
+ debug_warning("meta type is not id3v2\n");
+ goto exception;
+ }
- readed = mmfile_read (fp, (unsigned char *)id3v2Box.id3v2Data, id3v2Len);
- if (readed != id3v2Len)
- {
- debug_error ("read id3tag data error\n");
- goto exception;
- }
+ readed = mmfile_read(fp, (unsigned char *)&id3v2Box, MMFILE_3GP_ID3V2_BOX_LEN);
+ if (readed != MMFILE_3GP_ID3V2_BOX_LEN) {
+ debug_error("read id3v2 box\n");
+ goto exception;
+ }
- /* check id3v2 */
- if (!IS_ID3V2_TAG(id3v2Box.id3v2Data))
- {
- debug_error ("it is not id3tag\n");
- goto exception;
- }
+ id3v2Len = id3v2BoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_ID3V2_BOX_LEN;
- if (id3v2Box.id3v2Data[3] == 0xFF || id3v2Box.id3v2Data[4] == 0xFF ||
- id3v2Box.id3v2Data[6] >= 0x80 || id3v2Box.id3v2Data[7] >= 0x80 ||
- id3v2Box.id3v2Data[8] >= 0x80 || id3v2Box.id3v2Data[9] >= 0x80)
- {
- debug_error ("it is not valid id3tag\n");
- goto exception;
- }
+ id3v2Box.id3v2Data = mmfile_malloc(id3v2Len);
+ if (!id3v2Box.id3v2Data) {
+ debug_error("malloc id3tag data error\n");
+ goto exception;
+ }
- tagVersion = id3v2Box.id3v2Data[3];
- if ( tagVersion > 4)
- {
- debug_error ("tag vesion is too high\n");
- goto exception;
- }
+ readed = mmfile_read(fp, (unsigned char *)id3v2Box.id3v2Data, id3v2Len);
+ if (readed != id3v2Len) {
+ debug_error("read id3tag data error\n");
+ goto exception;
+ }
- encSize = mmfile_io_le_uint32(&id3v2Box.id3v2Data[6]);
- tagInfo.tagV2Info.tagLen = MP3_TAGv2_HEADER_LEN;
- tagInfo.tagV2Info.tagLen += (((encSize & 0x0000007F) >> 0) | ((encSize & 0x00007F00) >> 1) | ((encSize & 0x007F0000) >> 2) | ((encSize & 0x7F000000) >> 3));
- tagInfo.tagV2Info.tagVersion = tagVersion;
- tagInfo.fileLen = id3v2Len;
-
- /* set id3v2 data to formatContext */
- switch (tagVersion)
- {
- case 2:
- {
- versionCheck = mm_file_id3tag_parse_v222(&tagInfo, id3v2Box.id3v2Data);
- break;
+ /* check id3v2 */
+ if (!IS_ID3V2_TAG(id3v2Box.id3v2Data)) {
+ debug_error("it is not id3tag\n");
+ goto exception;
}
- case 3:
- {
- versionCheck = mm_file_id3tag_parse_v223(&tagInfo, id3v2Box.id3v2Data);
- break;
+
+ if (id3v2Box.id3v2Data[3] == 0xFF || id3v2Box.id3v2Data[4] == 0xFF ||
+ id3v2Box.id3v2Data[6] >= 0x80 || id3v2Box.id3v2Data[7] >= 0x80 ||
+ id3v2Box.id3v2Data[8] >= 0x80 || id3v2Box.id3v2Data[9] >= 0x80) {
+ debug_error("it is not valid id3tag\n");
+ goto exception;
}
- case 4:
- {
- versionCheck = mm_file_id3tag_parse_v224(&tagInfo, id3v2Box.id3v2Data);
- break;
+
+ tagVersion = id3v2Box.id3v2Data[3];
+ if (tagVersion > 4) {
+ debug_error("tag vesion is too high\n");
+ goto exception;
}
- case 1:
- default:
- {
- debug_error ("tag vesion is not support\n");
- versionCheck = false;
- break;
+
+ encSize = mmfile_io_le_uint32((unsigned int)&id3v2Box.id3v2Data[6]);
+ tagInfo.tagV2Info.tagLen = MP3_TAGv2_HEADER_LEN;
+ tagInfo.tagV2Info.tagLen += (((encSize & 0x0000007F) >> 0) | ((encSize & 0x00007F00) >> 1) | ((encSize & 0x007F0000) >> 2) | ((encSize & 0x7F000000) >> 3));
+ tagInfo.tagV2Info.tagVersion = tagVersion;
+ tagInfo.fileLen = id3v2Len;
+
+ /* set id3v2 data to formatContext */
+ switch (tagVersion) {
+ case 2: {
+ versionCheck = mm_file_id3tag_parse_v222(&tagInfo, id3v2Box.id3v2Data);
+ break;
+ }
+ case 3: {
+ versionCheck = mm_file_id3tag_parse_v223(&tagInfo, id3v2Box.id3v2Data);
+ break;
+ }
+ case 4: {
+ versionCheck = mm_file_id3tag_parse_v224(&tagInfo, id3v2Box.id3v2Data);
+ break;
+ }
+ case 1:
+ default: {
+ debug_error("tag vesion is not support\n");
+ versionCheck = false;
+ break;
+ }
}
- }
- if (versionCheck == false)
- {
- debug_error ("tag parsing is fail\n");
- goto exception;
- }
+ if (versionCheck == false) {
+ debug_error("tag parsing is fail\n");
+ goto exception;
+ }
- if (!formatContext->title) formatContext->title = mmfile_strdup((const char*)tagInfo.pTitle);
- if (!formatContext->artist) formatContext->artist = mmfile_strdup((const char*)tagInfo.pArtist);
- if (!formatContext->author) formatContext->author = mmfile_strdup((const char*)tagInfo.pAuthor);
- if (!formatContext->copyright) formatContext->copyright = mmfile_strdup((const char*)tagInfo.pCopyright);
- if (!formatContext->comment) formatContext->comment = mmfile_strdup((const char*)tagInfo.pComment);
- if (!formatContext->album) formatContext->album = mmfile_strdup((const char*)tagInfo.pAlbum);
- if (!formatContext->album_artist) formatContext->album_artist = mmfile_strdup((const char*)tagInfo.pAlbum_Artist);
- if (!formatContext->year) formatContext->year = mmfile_strdup((const char*)tagInfo.pYear);
- if (!formatContext->genre) formatContext->genre = mmfile_strdup((const char*)tagInfo.pGenre);
- if (!formatContext->tagTrackNum) formatContext->tagTrackNum = mmfile_strdup((const char*)tagInfo.pTrackNum);
- if (!formatContext->composer) formatContext->composer = mmfile_strdup((const char*)tagInfo.pComposer);
- if (!formatContext->classification) formatContext->classification = mmfile_strdup((const char*)tagInfo.pContentGroup);
- if (!formatContext->conductor) formatContext->conductor = mmfile_strdup((const char*)tagInfo.pConductor);
-
- formatContext->artwork = mmfile_malloc (tagInfo.imageInfo.imageLen);
- if ((tagInfo.imageInfo.imageLen > 0) && formatContext->artwork)
- {
- formatContext->artworkSize = tagInfo.imageInfo.imageLen;
- memcpy (formatContext->artwork, tagInfo.imageInfo.pImageBuf, tagInfo.imageInfo.imageLen);
- }
+ if (!formatContext->title) formatContext->title = mmfile_strdup((const char *)tagInfo.pTitle);
+ if (!formatContext->artist) formatContext->artist = mmfile_strdup((const char *)tagInfo.pArtist);
+ if (!formatContext->author) formatContext->author = mmfile_strdup((const char *)tagInfo.pAuthor);
+ if (!formatContext->copyright) formatContext->copyright = mmfile_strdup((const char *)tagInfo.pCopyright);
+ if (!formatContext->comment) formatContext->comment = mmfile_strdup((const char *)tagInfo.pComment);
+ if (!formatContext->album) formatContext->album = mmfile_strdup((const char *)tagInfo.pAlbum);
+ if (!formatContext->album_artist) formatContext->album_artist = mmfile_strdup((const char *)tagInfo.pAlbum_Artist);
+ if (!formatContext->year) formatContext->year = mmfile_strdup((const char *)tagInfo.pYear);
+ if (!formatContext->genre) formatContext->genre = mmfile_strdup((const char *)tagInfo.pGenre);
+ if (!formatContext->tagTrackNum) formatContext->tagTrackNum = mmfile_strdup((const char *)tagInfo.pTrackNum);
+ if (!formatContext->composer) formatContext->composer = mmfile_strdup((const char *)tagInfo.pComposer);
+ if (!formatContext->classification) formatContext->classification = mmfile_strdup((const char *)tagInfo.pContentGroup);
+ if (!formatContext->conductor) formatContext->conductor = mmfile_strdup((const char *)tagInfo.pConductor);
+
+ formatContext->artwork = mmfile_malloc(tagInfo.imageInfo.imageLen);
+ if ((tagInfo.imageInfo.imageLen > 0) && formatContext->artwork) {
+ formatContext->artworkSize = tagInfo.imageInfo.imageLen;
+ memcpy(formatContext->artwork, tagInfo.imageInfo.pImageBuf, tagInfo.imageInfo.imageLen);
+ }
- mm_file_free_AvFileContentInfo (&tagInfo);
- mmfile_free (id3v2Box.id3v2Data);
+ mm_file_free_AvFileContentInfo(&tagInfo);
+ mmfile_free(id3v2Box.id3v2Data);
- /*reset seek position*/
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ /*reset seek position*/
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
- return MMFILE_UTIL_SUCCESS;
+ return MMFILE_UTIL_SUCCESS;
- }
+ }
exception:
- mmfile_seek (fp, basic_header->start_offset + basic_header->size, SEEK_SET);
- mmfile_free (id3v2Box.id3v2Data);
- mm_file_free_AvFileContentInfo (&tagInfo);
+ mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
+ mmfile_free(id3v2Box.id3v2Data);
+ mm_file_free_AvFileContentInfo(&tagInfo);
return MMFILE_UTIL_FAIL;
}
-EXPORT_API int MMFileUtilGetMetaDataFromMP4 (MMFileFormatContext * formatContext)
+EXPORT_API int MMFileUtilGetMetaDataFromMP4(MMFileFormatContext *formatContext)
{
MMFileIOHandle *fp = NULL;
int ret = 0;
int readed;
- ret = mmfile_open (&fp, formatContext->uriFileName, MMFILE_RDONLY);
- if(ret == MMFILE_UTIL_FAIL) {
- debug_error ("error: mmfile_open\n");
+ ret = mmfile_open(&fp, formatContext->uriFileName, MMFILE_RDONLY);
+ if (ret == MMFILE_UTIL_FAIL) {
+ debug_error("error: mmfile_open\n");
goto exit;
}
- MMFILE_MP4_BASIC_BOX_HEADER basic_header = {0,};
- basic_header.start_offset = mmfile_tell (fp);
+ MMFILE_MP4_BASIC_BOX_HEADER basic_header = {0, };
+ basic_header.start_offset = mmfile_tell(fp);
- while ( (ret != MMFILE_UTIL_FAIL) && ((readed = mmfile_read (fp, (unsigned char *)&basic_header, MMFILE_MP4_BASIC_BOX_HEADER_LEN)) > 0 ) ) {
- basic_header.size = mmfile_io_be_uint32 (basic_header.size);
- basic_header.type = mmfile_io_le_uint32 (basic_header.type);
+ while ((ret != MMFILE_UTIL_FAIL) && ((readed = mmfile_read(fp, (unsigned char *)&basic_header, MMFILE_MP4_BASIC_BOX_HEADER_LEN)) > 0)) {
+ basic_header.size = mmfile_io_be_uint32(basic_header.size);
+ basic_header.type = mmfile_io_le_uint32(basic_header.type);
if (basic_header.size == 0) {
- debug_warning ("header is invalid.\n");
+ debug_warning("header is invalid.\n");
basic_header.size = readed;
basic_header.type = 0;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("START_OFFSET:[%lld] SIZE:[%d Byte] 4CC:[%c%c%c%c]\n",
- basic_header.start_offset, basic_header.size,
- ((char*)&basic_header.type)[0], ((char*)&basic_header.type)[1],
- ((char*)&basic_header.type)[2], ((char*)&basic_header.type)[3]);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("START_OFFSET:[%lld] SIZE:[%d Byte] 4CC:[%c%c%c%c]\n",
+ basic_header.start_offset, basic_header.size,
+ ((char *)&basic_header.type)[0], ((char *)&basic_header.type)[1],
+ ((char *)&basic_header.type)[2], ((char *)&basic_header.type)[3]);
+#endif
switch (basic_header.type) {
- case FOURCC ('m', 'o', 'o', 'v'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [moov] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- break;
- }
- case FOURCC ('u', 'd', 't', 'a'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [udat] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- break;
- }
- /////////////////////////////////////////////////////////////////
- // Extracting Tag Data //
- /////////////////////////////////////////////////////////////////
- case FOURCC ('t', 'i', 't', 'l'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [titl] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetStringFromTextTagBox (formatContext, fp, &basic_header, eMMFILE_3GP_TAG_TITLE);
- break;
- }
- case FOURCC ('d', 's', 'c', 'p'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [dscp] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetStringFromTextTagBox (formatContext, fp, &basic_header, eMMFILE_3GP_TAG_CAPTION);
- break;
- }
- case FOURCC ('c', 'p', 'r', 't'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [cprt] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetStringFromTextTagBox (formatContext, fp, &basic_header, eMMFILE_3GP_TAG_COPYRIGHT);
- break;
- }
- case FOURCC ('p', 'e', 'r', 'f'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [perf] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetStringFromTextTagBox (formatContext, fp, &basic_header, eMMFILE_3GP_TAG_PERFORMER );
- break;
- }
- case FOURCC ('a', 'u', 't', 'h'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [auth] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetStringFromTextTagBox (formatContext, fp, &basic_header, eMMFILE_3GP_TAG_AUTHOR);
- break;
- }
- case FOURCC ('g', 'n', 'r', 'e'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [gnre] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetStringFromTextTagBox (formatContext, fp, &basic_header, eMMFILE_3GP_TAG_GENRE);
- break;
- }
- case FOURCC ('a', 'l', 'b', 'm'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [albm] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetAlbumFromAlbumTagBox (formatContext, fp, &basic_header);
- break;
- }
- case FOURCC ('y', 'r', 'r', 'c'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [yrrc] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetYearFromYearTagBox (formatContext, fp, &basic_header);
- break;
- }
- case FOURCC ('r', 't', 'n', 'g'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [rtng] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetRatingFromRatingTagBox (formatContext, fp, &basic_header); /* not use */
- break;
- }
- case FOURCC ('c', 'l', 's', 'f'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [clsf] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetClassficationFromClsfTagBox (formatContext, fp, &basic_header);
- break;
- }
- case FOURCC ('k', 'y', 'w', 'd'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [kywd] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- ret = mmfile_seek (fp, basic_header.start_offset + basic_header.size, SEEK_SET);
- break;
- }
- case FOURCC ('l', 'o', 'c', 'i'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [loci] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetLocationFromLociTagBox (formatContext, fp, &basic_header);
- break;
- }
- /* Check smta in user data field to be compatible with android */
- case FOURCC ('s', 'm', 't', 'a'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [smta] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetSAUTInfoFromSMTATagBox (formatContext, fp, &basic_header);
- break;
- }
- /* Check smta in user data field to be compatible with android */
- case FOURCC ('c', 'd', 'i', 's'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [smta] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetValueFromCDISTagBox (formatContext, fp, &basic_header);
- break;
- }
- /////////////////////////////////////////////////////////////////
- // Extracting ID3 Tag Data //
- /////////////////////////////////////////////////////////////////
- case FOURCC ('m', 'e', 't', 'a'): {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MPEG4: [meta] SIZE: [%d]Byte\n", basic_header.size);
- #endif
- GetTagFromMetaBox (formatContext, fp, &basic_header);
- break;
- }
+ case FOURCC('m', 'o', 'o', 'v'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [moov] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ break;
+ }
+ case FOURCC('u', 'd', 't', 'a'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [udat] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ break;
+ }
+ /*/////////////////////////////////////////////////////////////// */
+ /* Extracting Tag Data // */
+ /*/////////////////////////////////////////////////////////////// */
+ case FOURCC('t', 'i', 't', 'l'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [titl] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetStringFromTextTagBox(formatContext, fp, &basic_header, eMMFILE_3GP_TAG_TITLE);
+ break;
+ }
+ case FOURCC('d', 's', 'c', 'p'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [dscp] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetStringFromTextTagBox(formatContext, fp, &basic_header, eMMFILE_3GP_TAG_CAPTION);
+ break;
+ }
+ case FOURCC('c', 'p', 'r', 't'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [cprt] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetStringFromTextTagBox(formatContext, fp, &basic_header, eMMFILE_3GP_TAG_COPYRIGHT);
+ break;
+ }
+ case FOURCC('p', 'e', 'r', 'f'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [perf] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetStringFromTextTagBox(formatContext, fp, &basic_header, eMMFILE_3GP_TAG_PERFORMER);
+ break;
+ }
+ case FOURCC('a', 'u', 't', 'h'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [auth] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetStringFromTextTagBox(formatContext, fp, &basic_header, eMMFILE_3GP_TAG_AUTHOR);
+ break;
+ }
+ case FOURCC('g', 'n', 'r', 'e'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [gnre] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetStringFromTextTagBox(formatContext, fp, &basic_header, eMMFILE_3GP_TAG_GENRE);
+ break;
+ }
+ case FOURCC('a', 'l', 'b', 'm'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [albm] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetAlbumFromAlbumTagBox(formatContext, fp, &basic_header);
+ break;
+ }
+ case FOURCC('y', 'r', 'r', 'c'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [yrrc] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetYearFromYearTagBox(formatContext, fp, &basic_header);
+ break;
+ }
+ case FOURCC('r', 't', 'n', 'g'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [rtng] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetRatingFromRatingTagBox(formatContext, fp, &basic_header); /* not use */
+ break;
+ }
+ case FOURCC('c', 'l', 's', 'f'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [clsf] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetClassficationFromClsfTagBox(formatContext, fp, &basic_header);
+ break;
+ }
+ case FOURCC('k', 'y', 'w', 'd'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [kywd] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ ret = mmfile_seek(fp, basic_header.start_offset + basic_header.size, SEEK_SET);
+ break;
+ }
+ case FOURCC('l', 'o', 'c', 'i'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [loci] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetLocationFromLociTagBox(formatContext, fp, &basic_header);
+ break;
+ }
+ /* Check smta in user data field to be compatible with android */
+ case FOURCC('s', 'm', 't', 'a'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [smta] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetSAUTInfoFromSMTATagBox(formatContext, fp, &basic_header);
+ break;
+ }
+ /* Check smta in user data field to be compatible with android */
+ case FOURCC('c', 'd', 'i', 's'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [smta] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetValueFromCDISTagBox(formatContext, fp, &basic_header);
+ break;
+ }
+ /*/////////////////////////////////////////////////////////////// */
+ /* Extracting ID3 Tag Data // */
+ /*/////////////////////////////////////////////////////////////// */
+ case FOURCC('m', 'e', 't', 'a'): {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MPEG4: [meta] SIZE: [%d]Byte\n", basic_header.size);
+#endif
+ GetTagFromMetaBox(formatContext, fp, &basic_header);
+ break;
+ }
default: {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("4CC: Not Support.. so skip it\n");
- #endif
- ret = mmfile_seek (fp, basic_header.start_offset + basic_header.size, SEEK_SET);
- break;
- }
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("4CC: Not Support.. so skip it\n");
+#endif
+ ret = mmfile_seek(fp, basic_header.start_offset + basic_header.size, SEEK_SET);
+ break;
+ }
}
if (ret == MMFILE_UTIL_FAIL) {
goto exit;
}
- basic_header.start_offset = mmfile_tell (fp);
+ basic_header.start_offset = mmfile_tell(fp);
}
exit:
- mmfile_close (fp);
+ mmfile_close(fp);
return ret;
}
-static char * get_string(const char *buf, int buf_size, int *bytes_written)
+static char *get_string(const char *buf, int buf_size, int *bytes_written)
{
int i = 0, c = 0;
char *q = NULL;
char str[512] = {0, };
q = str;
- for(i = 0; i < buf_size; i++) {
+ for (i = 0; i < buf_size; i++) {
c = buf[i];
if (c == '\0')
break;
- if ((q - str) >= sizeof(str) - 1)
- break;
+ if ((q - str) >= (int)sizeof(str) - 1)
+ break;
*q++ = c;
}
*q = '\0';
- if(strlen(str) > 0) {
+ if (strlen(str) > 0) {
*bytes_written = strlen(str);
return strdup(str);
} else {
int idx = 0;
bool is_num = true;
- for(idx = 0; idx < buf_size; idx++) {
- if(isdigit((int)buf[idx])) {
+ for (idx = 0; idx < buf_size; idx++) {
+ if (isdigit((int)buf[idx])) {
continue;
- }
- else {
+ } else {
is_num = false;
break;
}
return is_num;
}
-char* rtrimN(char* pStr)
+char *rtrimN(char *pStr)
{
int pos = 0;
- pos = strlen(pStr)-1;
- for (; pos>=0; pos--)
- {
- if (pStr[pos] == 0x20)
- {
+ pos = strlen(pStr) - 1;
+ for (; pos >= 0; pos--) {
+ if (pStr[pos] == 0x20) {
pStr[pos] = 0x00;
- }
- else
- {
+ } else {
break;
}
}
static bool make_characterset_array(char ***charset_array)
{
- char *locale = MMFileUtilGetLocale (NULL);
+ char *locale = MMFileUtilGetLocale(NULL);
- *charset_array = calloc(AV_ID3V2_MAX, sizeof(char*));
+ *charset_array = calloc(AV_ID3V2_MAX, sizeof(char *));
- if(*charset_array == NULL) {
+ if (*charset_array == NULL) {
debug_error("calloc failed ");
- if(locale != NULL)
+ if (locale != NULL)
free(locale);
return false;
}
int i = 0;
for (i = 0; i < AV_ID3V2_MAX; i++) {
- if (charset_array[i] != NULL)
- {
+ if (charset_array[i] != NULL) {
free(charset_array[i]);
charset_array[i] = NULL;
}
}
- if( charset_array != NULL ){
+ if (charset_array != NULL) {
free(charset_array);
charset_array = NULL;
}
return true;
}
-static void init_content_info(AvFileContentInfo* pInfo)
+static void init_content_info(AvFileContentInfo *pInfo)
{
pInfo->tagV2Info.bTitleMarked = false;
- pInfo->tagV2Info.bArtistMarked= false;
- pInfo->tagV2Info.bAlbumMarked= false;
- pInfo->tagV2Info.bAlbum_ArtistMarked= false;
- pInfo->tagV2Info.bYearMarked= false;
- pInfo->tagV2Info.bDescriptionMarked= false;
- pInfo->tagV2Info.bGenreMarked= false;
- pInfo->tagV2Info.bTrackNumMarked= false;
- pInfo->tagV2Info.bEncByMarked= false;
- pInfo->tagV2Info.bURLMarked= false;
- pInfo->tagV2Info.bCopyRightMarked= false;
- pInfo->tagV2Info.bOriginArtistMarked= false;
- pInfo->tagV2Info.bComposerMarked= false;
- pInfo->tagV2Info.bImageMarked= false;
-
- pInfo->tagV2Info.bRecDateMarked= false;
- pInfo->tagV2Info.bContentGroupMarked= false;
+ pInfo->tagV2Info.bArtistMarked = false;
+ pInfo->tagV2Info.bAlbumMarked = false;
+ pInfo->tagV2Info.bAlbum_ArtistMarked = false;
+ pInfo->tagV2Info.bYearMarked = false;
+ pInfo->tagV2Info.bDescriptionMarked = false;
+ pInfo->tagV2Info.bGenreMarked = false;
+ pInfo->tagV2Info.bTrackNumMarked = false;
+ pInfo->tagV2Info.bEncByMarked = false;
+ pInfo->tagV2Info.bURLMarked = false;
+ pInfo->tagV2Info.bCopyRightMarked = false;
+ pInfo->tagV2Info.bOriginArtistMarked = false;
+ pInfo->tagV2Info.bComposerMarked = false;
+ pInfo->tagV2Info.bImageMarked = false;
+
+ pInfo->tagV2Info.bRecDateMarked = false;
+ pInfo->tagV2Info.bContentGroupMarked = false;
pInfo->tagV2Info.bUnsyncLyricsMarked = false;
pInfo->tagV2Info.bSyncLyricsMarked = false;
}
EXPORT_API
-bool mm_file_id3tag_parse_v110(AvFileContentInfo* pInfo, unsigned char *buffer)
+bool mm_file_id3tag_parse_v110(AvFileContentInfo *pInfo, unsigned char *buffer)
{
- const char *locale = MMFileUtilGetLocale (NULL);
- char* pFullStr = NULL;
+ const char *locale = MMFileUtilGetLocale(NULL);
+ char *pFullStr = NULL;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ID3tag v110--------------------------------------------------------------\n");
+ debug_msg("ID3tag v110--------------------------------------------------------------\n");
#endif
- if(pInfo->tagV2Info.bTitleMarked == false) {
- pFullStr = mmfile_string_convert ((const char*)&buffer[3], MP3_ID3_TITLE_LENGTH, "UTF-8", locale, NULL, (unsigned int*)&pInfo->titleLen);
- if (pFullStr !=NULL)
- {
+ if (pInfo->tagV2Info.bTitleMarked == false) {
+ pFullStr = mmfile_string_convert((const char *)&buffer[3], MP3_ID3_TITLE_LENGTH, "UTF-8", locale, NULL, (unsigned int *)&pInfo->titleLen);
+ if (pFullStr != NULL) {
pInfo->pTitle = rtrimN(pFullStr);
free(pFullStr);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTitle returned =(%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTitle returned =(%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
+#endif
}
- if(pInfo->tagV2Info.bArtistMarked == false) {
- pFullStr = mmfile_string_convert ((const char*)&buffer[33], MP3_ID3_ARTIST_LENGTH, "UTF-8", locale, NULL, (unsigned int*)&pInfo->artistLen);
- if (pFullStr !=NULL)
- {
+ if (pInfo->tagV2Info.bArtistMarked == false) {
+ pFullStr = mmfile_string_convert((const char *)&buffer[33], MP3_ID3_ARTIST_LENGTH, "UTF-8", locale, NULL, (unsigned int *)&pInfo->artistLen);
+ if (pFullStr != NULL) {
pInfo->pArtist = rtrimN(pFullStr);
free(pFullStr);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pArtist returned =(%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pArtist returned =(%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
+#endif
}
- if(pInfo->tagV2Info.bAlbumMarked == false) {
- pFullStr = mmfile_string_convert ((const char*)&buffer[63], MP3_ID3_ALBUM_LENGTH, "UTF-8", locale, NULL, (unsigned int*)&pInfo->albumLen);
- if (pFullStr !=NULL)
- {
+ if (pInfo->tagV2Info.bAlbumMarked == false) {
+ pFullStr = mmfile_string_convert((const char *)&buffer[63], MP3_ID3_ALBUM_LENGTH, "UTF-8", locale, NULL, (unsigned int *)&pInfo->albumLen);
+ if (pFullStr != NULL) {
pInfo->pAlbum = rtrimN(pFullStr);
free(pFullStr);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum returned =(%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum returned =(%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
+#endif
}
- if(pInfo->tagV2Info.bYearMarked == false) {
+ if (pInfo->tagV2Info.bYearMarked == false) {
- pInfo->pYear = mmfile_string_convert ((const char*)&buffer[93], MP3_ID3_YEAR_LENGTH, "UTF-8", locale, NULL, (unsigned int*)&pInfo->yearLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pYear returned =(%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
- #endif
+ pInfo->pYear = mmfile_string_convert((const char *)&buffer[93], MP3_ID3_YEAR_LENGTH, "UTF-8", locale, NULL, (unsigned int *)&pInfo->yearLen);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pYear returned =(%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
+#endif
- if(pInfo->pYear == NULL) { /*Use same logic with ffmpeg*/
- pInfo->pYear = get_string((const char*)&buffer[93], MP3_ID3_YEAR_LENGTH, (int*)&pInfo->yearLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pYear returned =(%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
- #endif
+ if (pInfo->pYear == NULL) { /*Use same logic with ffmpeg*/
+ pInfo->pYear = get_string((const char *)&buffer[93], MP3_ID3_YEAR_LENGTH, (int *)&pInfo->yearLen);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pYear returned =(%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
+#endif
}
}
- if(pInfo->tagV2Info.bDescriptionMarked == false) {
- pInfo->pComment = mmfile_string_convert ((const char*)&buffer[97], MP3_ID3_DESCRIPTION_LENGTH, "UTF-8", locale, NULL, (unsigned int*)&pInfo->commentLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
- #endif
-
- if(pInfo->pComment == NULL) { /*Use same logic with ffmpeg*/
- pInfo->pComment = get_string((const char*)&buffer[97], MP3_ID3_DESCRIPTION_LENGTH, (int*)&pInfo->commentLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
- #endif
+ if (pInfo->tagV2Info.bDescriptionMarked == false) {
+ pInfo->pComment = mmfile_string_convert((const char *)&buffer[97], MP3_ID3_DESCRIPTION_LENGTH, "UTF-8", locale, NULL, (unsigned int *)&pInfo->commentLen);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
+#endif
+
+ if (pInfo->pComment == NULL) { /*Use same logic with ffmpeg*/
+ pInfo->pComment = get_string((const char *)&buffer[97], MP3_ID3_DESCRIPTION_LENGTH, (int *)&pInfo->commentLen);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
+#endif
}
}
- if(pInfo->tagV2Info.bTrackNumMarked== false) {
- pInfo->pTrackNum = mmfile_malloc (5);
- if(pInfo->pTrackNum != NULL) {
+ if (pInfo->tagV2Info.bTrackNumMarked == false) {
+ pInfo->pTrackNum = mmfile_malloc(5);
+ if (pInfo->pTrackNum != NULL) {
pInfo->pTrackNum[4] = 0;
snprintf(pInfo->pTrackNum, 4, "%04d", (int)buffer[126]);
pInfo->tracknumLen = strlen(pInfo->pTrackNum);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTrackNum returned =(%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTrackNum returned =(%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
+#endif
}
}
- if(pInfo->tagV2Info.bGenreMarked == false) {
+ if (pInfo->tagV2Info.bGenreMarked == false) {
pInfo->genre = buffer[127];
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->genre returned genre number (%d)\n", pInfo->genre);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->genre returned genre number (%d)\n", pInfo->genre);
+#endif
}
return true;
}
EXPORT_API
-bool mm_file_id3tag_parse_v222(AvFileContentInfo* pInfo, unsigned char *buffer)
+bool mm_file_id3tag_parse_v222(AvFileContentInfo *pInfo, unsigned char *buffer)
{
unsigned long taglen = 0;
unsigned long needToloopv2taglen;
char CompTmp[4];
char *pExtContent = NULL;
unsigned long purelyFramelen = 0;
- int inx=0, encodingOffSet=0, realCpyFrameNum=0,
- checkImgMimeTypeMax=0, checkImgExtMax=0,
- imgstartOffset=0, tmp = 0;
+ unsigned int encodingOffSet = 0;
+ int inx = 0, realCpyFrameNum = 0,
+ /*checkImgMimeTypeMax = 0, */checkImgExtMax = 0,
+ imgstartOffset = 0, tmp = 0;
int textEncodingType = 0;
taglen = pInfo->tagV2Info.tagLen;
needToloopv2taglen = taglen - MP3_TAGv2_HEADER_LEN;
curPos = MP3_TAGv2_HEADER_LEN;
-
+
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ID3tag v222--------------------------------------------------------------\n");
+ debug_msg("ID3tag v222--------------------------------------------------------------\n");
#endif
- if(needToloopv2taglen -MP3_TAGv2_22_TXT_HEADER_LEN > MP3_TAGv2_22_TXT_HEADER_LEN) {
+ if (needToloopv2taglen - MP3_TAGv2_22_TXT_HEADER_LEN > MP3_TAGv2_22_TXT_HEADER_LEN) {
v2numOfFrames = 1;
- while(needToloopv2taglen > MP3_TAGv2_22_TXT_HEADER_LEN)
- {
- if((buffer[curPos] < '0' || buffer[curPos] > 'Z') || (buffer[curPos+1] < '0' || buffer[curPos+1] > 'Z')
- || (buffer[curPos+2] < '0' || buffer[curPos+2] > 'Z'))
+ while (needToloopv2taglen > MP3_TAGv2_22_TXT_HEADER_LEN) {
+ if ((buffer[curPos] < '0' || buffer[curPos] > 'Z') || (buffer[curPos + 1] < '0' || buffer[curPos + 1] > 'Z')
+ || (buffer[curPos + 2] < '0' || buffer[curPos + 2] > 'Z'))
break;
memcpy(CompTmp, &buffer[curPos], 3);
CompTmp[3] = 0;
oneFrameLen = MP3_TAGv2_22_TXT_HEADER_LEN;
- oneFrameLen += (unsigned long)buffer[3+curPos] << 16 | (unsigned long)buffer[4+curPos] << 8
- | (unsigned long)buffer[5+curPos];
- if(oneFrameLen > taglen-curPos)
+ oneFrameLen += (unsigned long)buffer[3 + curPos] << 16 | (unsigned long)buffer[4 + curPos] << 8
+ | (unsigned long)buffer[5 + curPos];
+ if (oneFrameLen > taglen - curPos)
break;
purelyFramelen = oneFrameLen - MP3_TAGv2_22_TXT_HEADER_LEN;
- curPos +=MP3_TAGv2_22_TXT_HEADER_LEN;
+ curPos += MP3_TAGv2_22_TXT_HEADER_LEN;
- if(oneFrameLen > MP3_TAGv2_22_TXT_HEADER_LEN && purelyFramelen <= taglen-curPos)
- {
+ if (oneFrameLen > MP3_TAGv2_22_TXT_HEADER_LEN && purelyFramelen <= taglen - curPos) {
curPos += purelyFramelen;
- if(buffer[curPos-purelyFramelen] == 0x00)
- {
+ if (buffer[curPos - purelyFramelen] == 0x00) {
encodingOffSet = 1;
textEncodingType = AV_ID3V2_ISO_8859;
- }
- else if(buffer[curPos-purelyFramelen] == 0x01)
- {
+ } else if (buffer[curPos - purelyFramelen] == 0x01) {
encodingOffSet = 1;
textEncodingType = AV_ID3V2_UTF16;
}
if (textEncodingType > AV_ID3V2_MAX) {
- debug_msg ( "WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char*)CompTmp);
+ debug_msg("WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char *)CompTmp);
continue;
}
- //in order to deliver valid string to MP
- while((buffer[curPos-purelyFramelen+encodingOffSet] < 0x20) && (encodingOffSet < purelyFramelen))
+ /*in order to deliver valid string to MP */
+ while ((buffer[curPos - purelyFramelen + encodingOffSet] < 0x20) && (encodingOffSet < purelyFramelen))
encodingOffSet++;
- if(encodingOffSet < purelyFramelen)
- {
+ if (encodingOffSet < purelyFramelen) {
realCpyFrameNum = purelyFramelen - encodingOffSet;
- pExtContent = mmfile_malloc (realCpyFrameNum+3);
- memset(pExtContent, '\0', realCpyFrameNum+3);
+ pExtContent = mmfile_malloc(realCpyFrameNum + 3);
+ memset(pExtContent, '\0', realCpyFrameNum + 3);
- memcpy(pExtContent, &buffer[curPos-purelyFramelen+encodingOffSet], purelyFramelen-encodingOffSet);
+ memcpy(pExtContent, &buffer[curPos - purelyFramelen + encodingOffSet], purelyFramelen - encodingOffSet);
- if(realCpyFrameNum > 0)
- {
- if(strncmp((char *)CompTmp, "TT2", 3) == 0 && pInfo->tagV2Info.bTitleMarked == false)
- {
- pInfo->pTitle = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->titleLen);
+ if (realCpyFrameNum > 0) {
+ if (strncmp((char *)CompTmp, "TT2", 3) == 0 && pInfo->tagV2Info.bTitleMarked == false) {
+ pInfo->pTitle = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->titleLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
- #endif
- pInfo->tagV2Info.bTitleMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TP1", 3) == 0 && pInfo->tagV2Info.bArtistMarked == false)
- {
- pInfo->pArtist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->artistLen);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
+#endif
+ pInfo->tagV2Info.bTitleMarked = true;
+ } else if (strncmp((char *)CompTmp, "TP1", 3) == 0 && pInfo->tagV2Info.bArtistMarked == false) {
+ pInfo->pArtist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->artistLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
+#endif
pInfo->tagV2Info.bArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TP2", 3) == 0 && pInfo->tagV2Info.bAlbum_ArtistMarked == false)
- {
- pInfo->pAlbum_Artist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->album_artistLen);
+ } else if (strncmp((char *)CompTmp, "TP2", 3) == 0 && pInfo->tagV2Info.bAlbum_ArtistMarked == false) {
+ pInfo->pAlbum_Artist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->album_artistLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
+#endif
pInfo->tagV2Info.bAlbum_ArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TP3", 3) == 0 && pInfo->tagV2Info.bConductorMarked == false)
- {
- pInfo->pConductor = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->conductorLen);
+ } else if (strncmp((char *)CompTmp, "TP3", 3) == 0 && pInfo->tagV2Info.bConductorMarked == false) {
+ pInfo->pConductor = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->conductorLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
+#endif
pInfo->tagV2Info.bConductorMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TAL", 3) == 0 && pInfo->tagV2Info.bAlbumMarked == false)
- {
- pInfo->pAlbum = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->albumLen);
+ } else if (strncmp((char *)CompTmp, "TAL", 3) == 0 && pInfo->tagV2Info.bAlbumMarked == false) {
+ pInfo->pAlbum = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->albumLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
+#endif
pInfo->tagV2Info.bAlbumMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TYE", 3) == 0 && pInfo->tagV2Info.bYearMarked == false)
- {
- pInfo->pYear = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->yearLen);
+ } else if (strncmp((char *)CompTmp, "TYE", 3) == 0 && pInfo->tagV2Info.bYearMarked == false) {
+ pInfo->pYear = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->yearLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
+#endif
pInfo->tagV2Info.bYearMarked = true;
- }
- else if(strncmp((char *)CompTmp, "COM", 3) == 0 && pInfo->tagV2Info.bDescriptionMarked == false)
- {
- //skip language data!
- if(realCpyFrameNum > 4)
- {
+ } else if (strncmp((char *)CompTmp, "COM", 3) == 0 && pInfo->tagV2Info.bDescriptionMarked == false) {
+ /*skip language data! */
+ if (realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp = 4;
- //pExtContent[tmp+1] value should't have encoding value
- if(pExtContent[tmp] > 0x20 && (pExtContent[tmp - 1] == 0x00 || pExtContent[tmp - 1] == 0x01))
- {
- if(pExtContent[tmp - 1] == 0x00)
+ /*pExtContent[tmp+1] value should't have encoding value */
+ if (pExtContent[tmp] > 0x20 && (pExtContent[tmp - 1] == 0x00 || pExtContent[tmp - 1] == 0x01)) {
+ if (pExtContent[tmp - 1] == 0x00)
textEncodingType = AV_ID3V2_ISO_8859;
else
textEncodingType = AV_ID3V2_UTF16;
- pInfo->pComment = mmfile_string_convert ((char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->commentLen);
+ pInfo->pComment = mmfile_string_convert((char *)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->commentLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
+#endif
pInfo->tagV2Info.bDescriptionMarked = true;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mmf_file_id3tag_parse_v222: failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mmf_file_id3tag_parse_v222: failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet );
- #endif
- }
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mmf_file_id3tag_parse_v222: Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum );
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mmf_file_id3tag_parse_v222: Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
}
tmp = 0;
- }
- else if(strncmp((char *)CompTmp, "TCO", 3) == 0 && pInfo->tagV2Info.bGenreMarked == false)
- {
- pInfo->pGenre = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->genreLen);
+ } else if (strncmp((char *)CompTmp, "TCO", 3) == 0 && pInfo->tagV2Info.bGenreMarked == false) {
+ pInfo->pGenre = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->genreLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
+#endif
- if((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
+ if ((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
bool ret = FALSE;
int int_genre = -1;
ret = is_numeric(pInfo->pGenre, pInfo->genreLen);
- if(ret == TRUE) {
- sscanf( pInfo->pGenre, "%d", &int_genre);
- #ifdef __MMFILE_TEST_MODE__
+ if (ret == TRUE) {
+ sscanf(pInfo->pGenre, "%d", &int_genre);
+#ifdef __MMFILE_TEST_MODE__
debug_msg("genre information is inteager [%d]\n", int_genre);
- #endif
+#endif
- //Change int to string
- if((0 <= int_genre) && (int_genre < GENRE_COUNT-1)) {
+ /*Change int to string */
+ if ((0 <= int_genre) && (int_genre < GENRE_COUNT - 1)) {
/*save genreinfo like "(123)". mm_file_id3tag_restore_content_info convert it to string*/
- char tmp_genre[6] = {0,}; /*ex. "(123)+NULL"*/
+ char tmp_genre[6] = {0, }; /*ex. "(123)+NULL"*/
int tmp_genre_len = 0;
- memset (tmp_genre, 0, 6);
+ memset(tmp_genre, 0, 6);
snprintf(tmp_genre, sizeof(tmp_genre), "(%d)", int_genre);
tmp_genre_len = strlen(tmp_genre);
- if(tmp_genre_len > 0) {
- if(pInfo->pGenre) _FREE_EX(pInfo->pGenre);
- pInfo->pGenre = mmfile_malloc (sizeof(char) * (tmp_genre_len + 1) );
- if (pInfo->pGenre)
- {
+ if (tmp_genre_len > 0) {
+ if (pInfo->pGenre) _FREE_EX(pInfo->pGenre);
+ pInfo->pGenre = mmfile_malloc(sizeof(char) * (tmp_genre_len + 1));
+ if (pInfo->pGenre) {
strncpy(pInfo->pGenre, tmp_genre, tmp_genre_len);
pInfo->pGenre[tmp_genre_len] = 0;
}
}
pInfo->tagV2Info.bGenreMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TRK", 3) == 0 && pInfo->tagV2Info.bTrackNumMarked == false)
- {
- pInfo->pTrackNum = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->tracknumLen);
+ } else if (strncmp((char *)CompTmp, "TRK", 3) == 0 && pInfo->tagV2Info.bTrackNumMarked == false) {
+ pInfo->pTrackNum = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->tracknumLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
+#endif
pInfo->tagV2Info.bTrackNumMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TEN", 3) == 0 && pInfo->tagV2Info.bEncByMarked == false)
- {
- pInfo->pEncBy = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->encbyLen);
+ } else if (strncmp((char *)CompTmp, "TEN", 3) == 0 && pInfo->tagV2Info.bEncByMarked == false) {
+ pInfo->pEncBy = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->encbyLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
+#endif
pInfo->tagV2Info.bEncByMarked = true;
- }
- else if(strncmp((char *)CompTmp, "WXX", 3) == 0 && pInfo->tagV2Info.bURLMarked == false)
- {
- if(realCpyFrameNum > 4)
- {
- //skip language data!
+ } else if (strncmp((char *)CompTmp, "WXX", 3) == 0 && pInfo->tagV2Info.bURLMarked == false) {
+ if (realCpyFrameNum > 4) {
+ /*skip language data! */
realCpyFrameNum -= 4;
tmp = 4;
- //pExtContent[tmp+1] value should't have null value
- if(pExtContent[tmp] > 0x20 && (pExtContent[tmp - 1] == 0x00 || pExtContent[tmp - 1] == 0x01))
- {
- if(pExtContent[tmp - 1] == 0x00)
+ /*pExtContent[tmp+1] value should't have null value */
+ if (pExtContent[tmp] > 0x20 && (pExtContent[tmp - 1] == 0x00 || pExtContent[tmp - 1] == 0x01)) {
+ if (pExtContent[tmp - 1] == 0x00)
textEncodingType = AV_ID3V2_ISO_8859;
else
textEncodingType = AV_ID3V2_UTF16;
- pInfo->pURL = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->urlLen);
+ pInfo->pURL = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->urlLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
+#endif
pInfo->tagV2Info.bURLMarked = true;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mmf_file_id3tag_parse_v222: failed to get URL Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mmf_file_id3tag_parse_v222: failed to get URL Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet );
- #endif
- }
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mmf_file_id3tag_parse_v222: URL info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum );
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mmf_file_id3tag_parse_v222: URL info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
}
tmp = 0;
- }
- else if(strncmp((char *)CompTmp, "TCR", 3) == 0 && pInfo->tagV2Info.bCopyRightMarked == false)
- {
- pInfo->pCopyright = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->copyrightLen);
+ } else if (strncmp((char *)CompTmp, "TCR", 3) == 0 && pInfo->tagV2Info.bCopyRightMarked == false) {
+ pInfo->pCopyright = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->copyrightLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
+#endif
pInfo->tagV2Info.bCopyRightMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TOA", 3) == 0 && pInfo->tagV2Info.bOriginArtistMarked == false)
- {
- pInfo->pOriginArtist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->originartistLen);
+ } else if (strncmp((char *)CompTmp, "TOA", 3) == 0 && pInfo->tagV2Info.bOriginArtistMarked == false) {
+ pInfo->pOriginArtist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->originartistLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
+#endif
pInfo->tagV2Info.bOriginArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TCM", 3) == 0 && pInfo->tagV2Info.bComposerMarked == false)
- {
- pInfo->pComposer = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->composerLen);
+ } else if (strncmp((char *)CompTmp, "TCM", 3) == 0 && pInfo->tagV2Info.bComposerMarked == false) {
+ pInfo->pComposer = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->composerLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
+#endif
pInfo->tagV2Info.bComposerMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TRD", 3) == 0 && pInfo->tagV2Info.bRecDateMarked== false)
- {
- pInfo->pRecDate = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->recdateLen);
+ } else if (strncmp((char *)CompTmp, "TRD", 3) == 0 && pInfo->tagV2Info.bRecDateMarked == false) {
+ pInfo->pRecDate = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->recdateLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
+#endif
pInfo->tagV2Info.bRecDateMarked = true;
- }
- else if(strncmp((char *)CompTmp, "PIC", 3) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000)
- {
- if(pExtContent[0] != 0)
- {
- for(inx = 0; inx < MP3_ID3_IMAGE_EXT_MAX_LENGTH; inx++)
- pInfo->imageInfo.imageExt[inx] = '\0';//ini mimetype variable
-
- while((checkImgExtMax < MP3_ID3_IMAGE_EXT_MAX_LENGTH-1) && pExtContent[checkImgExtMax] != '\0')
- {
+ } else if (strncmp((char *)CompTmp, "PIC", 3) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000) {
+ if (pExtContent[0] != 0) {
+ for (inx = 0; inx < MP3_ID3_IMAGE_EXT_MAX_LENGTH; inx++)
+ pInfo->imageInfo.imageExt[inx] = '\0';/*ini mimetype variable */
+
+ while ((checkImgExtMax < MP3_ID3_IMAGE_EXT_MAX_LENGTH - 1) && pExtContent[checkImgExtMax] != '\0') {
pInfo->imageInfo.imageExt[checkImgExtMax] = pExtContent[checkImgExtMax];
checkImgExtMax++;
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mmf_file_id3tag_parse_v222: PIC image's not included to image Extention\n");
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mmf_file_id3tag_parse_v222: PIC image's not included to image Extention\n");
+#endif
}
imgstartOffset += checkImgExtMax;
- if(pExtContent[imgstartOffset] < AV_ID3V2_PICTURE_TYPE_MAX)
- {
+ if (pExtContent[imgstartOffset] < AV_ID3V2_PICTURE_TYPE_MAX) {
pInfo->imageInfo.pictureType = pExtContent[imgstartOffset];
}
- imgstartOffset++;//PictureType(1byte)
+ imgstartOffset++;/*PictureType(1byte) */
- if(pExtContent[imgstartOffset] != 0x0)
- {
+ if (pExtContent[imgstartOffset] != 0x0) {
int cur_pos = 0;
int dis_len = 0;
int new_dis_len = 0;
char jpg_sign[3] = {0xff, 0xd8, 0xff};
- char png_sign[8] = {0x80, 0x50, 0x4e, 0x47,0x0d, 0x0a, 0x1a, 0x0a};
+ char png_sign[8] = {0x80, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
char *tmp_desc = NULL;
while (1) {
if (pExtContent[imgstartOffset + cur_pos] == '\0') {
if (realCpyFrameNum < imgstartOffset + cur_pos) {
- debug_error("End of APIC Tag %d %d %d\n", realCpyFrameNum, imgstartOffset, cur_pos);
- break;
+ debug_error("End of APIC Tag %d %d %d\n", realCpyFrameNum, imgstartOffset, cur_pos);
+ break;
}
/*check end of image description*/
if ((pExtContent[imgstartOffset + cur_pos + 1] == jpg_sign[0]) ||
- (pExtContent[imgstartOffset + cur_pos + 1] == png_sign[0])) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "length of description (%d)", cur_pos);
- #endif
+ (pExtContent[imgstartOffset + cur_pos + 1] == png_sign[0])) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("length of description (%d)", cur_pos);
+#endif
break;
}
}
- cur_pos ++;
+ cur_pos++;
}
dis_len = cur_pos + 1;
tmp_desc = mmfile_malloc(sizeof(char) * dis_len);
- memcpy(tmp_desc, pExtContent + imgstartOffset, dis_len);
- /*convert description*/
- pInfo->imageInfo.imageDescription = mmfile_string_convert (tmp_desc, dis_len, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&new_dis_len);
- mmfile_free(tmp_desc);
+ if(tmp_desc != NULL) {
+ memcpy(tmp_desc, pExtContent + imgstartOffset, dis_len);
+
+ /*convert description*/
+ pInfo->imageInfo.imageDescription = mmfile_string_convert(tmp_desc, dis_len, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&new_dis_len);
+ mmfile_free(tmp_desc);
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
+#endif
+ pInfo->imageInfo.imgDesLen = new_dis_len; /**/
+ }
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
- #endif
- pInfo->imageInfo.imgDesLen = new_dis_len; /**/
imgstartOffset += cur_pos;
- }
- else
- {
- pInfo->imageInfo.imgDesLen= 0;
+ } else {
+ pInfo->imageInfo.imgDesLen = 0;
}
- if((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0))
- {
- imgstartOffset ++; // endofDesceriptionType(1byte)
+ if ((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0)) {
+ imgstartOffset++; /* endofDesceriptionType(1byte) */
- while(pExtContent[imgstartOffset] == '\0') //some content has useless '\0' in front of picture data
- {
- imgstartOffset ++;
+ while (pExtContent[imgstartOffset] == '\0') { /*some content has useless '\0' in front of picture data */
+ imgstartOffset++;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
+#endif
- if(realCpyFrameNum - imgstartOffset > 0)
- {
+ if (realCpyFrameNum - imgstartOffset > 0) {
pInfo->imageInfo.imageLen = realCpyFrameNum - imgstartOffset;
- pInfo->imageInfo.pImageBuf= mmfile_malloc (pInfo->imageInfo.imageLen + 1);
+ pInfo->imageInfo.pImageBuf = mmfile_malloc(pInfo->imageInfo.imageLen + 1);
- if(pInfo->imageInfo.pImageBuf != NULL) {
- memcpy(pInfo->imageInfo.pImageBuf, pExtContent+ imgstartOffset, pInfo->imageInfo.imageLen);
+ if (pInfo->imageInfo.pImageBuf != NULL) {
+ memcpy(pInfo->imageInfo.pImageBuf, pExtContent + imgstartOffset, pInfo->imageInfo.imageLen);
pInfo->imageInfo.pImageBuf[pInfo->imageInfo.imageLen] = 0;
}
- if(IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
- pInfo->imageInfo.bURLInfo = true; //if mimetype is "-->", image date has an URL
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
- #endif
+ if (IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
+ pInfo->imageInfo.bURLInfo = true; /*if mimetype is "-->", image date has an URL */
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
+#endif
}
}
- checkImgMimeTypeMax = 0;
+ /*checkImgMimeTypeMax = 0;*/
checkImgExtMax = 0;
inx = 0;
imgstartOffset = 0;
- pInfo->tagV2Info.bImageMarked= true;
+ pInfo->tagV2Info.bImageMarked = true;
}
}
}
- }
- else
- {
+ } else {
curPos += purelyFramelen;
- if(purelyFramelen != 0)
+ if (purelyFramelen != 0)
needToloopv2taglen = MP3_TAGv2_22_TXT_HEADER_LEN;
}
- if(pExtContent) _FREE_EX(pExtContent);
+ if (pExtContent) _FREE_EX(pExtContent);
memset(CompTmp, 0, 4);
- if(curPos < taglen)
- {
+ if (curPos < taglen) {
needToloopv2taglen -= oneFrameLen;
v2numOfFrames++;
- }
- else
+ } else
needToloopv2taglen = MP3_TAGv2_22_TXT_HEADER_LEN;
oneFrameLen = 0;
encodingOffSet = 0;
release_characterset_array(charset_array);
- if(taglen) {
+ if (taglen) {
return true;
} else {
return false;
}
EXPORT_API
-bool mm_file_id3tag_parse_v223(AvFileContentInfo* pInfo, unsigned char *buffer)
+bool mm_file_id3tag_parse_v223(AvFileContentInfo *pInfo, unsigned char *buffer)
{
unsigned long taglen = 0;
unsigned long needToloopv2taglen;
char CompTmp[5];
unsigned char *pExtContent = NULL;
unsigned long purelyFramelen = 0;
- int inx=0, encodingOffSet=0, realCpyFrameNum=0, checkImgMimeTypeMax=0, imgstartOffset=0, tmp = 0;
+ unsigned int encodingOffSet = 0;
+ int inx = 0, realCpyFrameNum = 0, checkImgMimeTypeMax = 0, imgstartOffset = 0, tmp = 0;
int textEncodingType = 0;
char **charset_array = NULL;
- char *MIME_PRFIX = "image/";
+ const char *MIME_PRFIX = "image/";
make_characterset_array(&charset_array);
curPos = MP3_TAGv2_HEADER_LEN;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ID3tag v223--------------------------------------------------------------\n");
+ debug_msg("ID3tag v223--------------------------------------------------------------\n");
#endif
/* check Extended Header */
- if (buffer[5] & 0x40)
- {
+ if (buffer[5] & 0x40) {
/* if extended header exists, skip it*/
int extendedHeaderLen = (unsigned long)buffer[10] << 21 | (unsigned long)buffer[11] << 14 | (unsigned long)buffer[12] << 7 | (unsigned long)buffer[13];
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("--------------- extendedHeaderLen = %d\n", extendedHeaderLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("--------------- extendedHeaderLen = %d\n", extendedHeaderLen);
+#endif
curPos += extendedHeaderLen;
curPos += 4;
}
- if(needToloopv2taglen -MP3_TAGv2_23_TXT_HEADER_LEN > MP3_TAGv2_23_TXT_HEADER_LEN)
- {
+ if (needToloopv2taglen - MP3_TAGv2_23_TXT_HEADER_LEN > MP3_TAGv2_23_TXT_HEADER_LEN) {
v2numOfFrames = 1;
- while(needToloopv2taglen > MP3_TAGv2_23_TXT_HEADER_LEN)
- {
- if((buffer[curPos] < '0' || buffer[curPos] > 'Z') || (buffer[curPos+1] < '0' || buffer[curPos+1] > 'Z')
- || (buffer[curPos+2] < '0' || buffer[curPos+2] > 'Z')|| (buffer[curPos+3] < '0' || buffer[curPos+3] > 'Z'))
+ while (needToloopv2taglen > MP3_TAGv2_23_TXT_HEADER_LEN) {
+ if ((buffer[curPos] < '0' || buffer[curPos] > 'Z') || (buffer[curPos + 1] < '0' || buffer[curPos + 1] > 'Z')
+ || (buffer[curPos + 2] < '0' || buffer[curPos + 2] > 'Z') || (buffer[curPos + 3] < '0' || buffer[curPos + 3] > 'Z'))
break;
memcpy(CompTmp, &buffer[curPos], 4);
CompTmp[4] = 0;
oneFrameLen = MP3_TAGv2_23_TXT_HEADER_LEN;
- oneFrameLen += (unsigned long)buffer[4+curPos] << 24 | (unsigned long)buffer[5+curPos] << 16
- | (unsigned long)buffer[6+curPos] << 8 | (unsigned long)buffer[7+curPos];
-
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("----------------------------------------------------------------------------------------------------\n");
- #endif
-
- if(oneFrameLen > taglen-curPos)
+ oneFrameLen += (unsigned long)buffer[4 + curPos] << 24 | (unsigned long)buffer[5 + curPos] << 16
+ | (unsigned long)buffer[6 + curPos] << 8 | (unsigned long)buffer[7 + curPos];
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("----------------------------------------------------------------------------------------------------\n");
+#endif
+
+ if (oneFrameLen > taglen - curPos)
break;
purelyFramelen = oneFrameLen - MP3_TAGv2_23_TXT_HEADER_LEN;
- curPos +=MP3_TAGv2_23_TXT_HEADER_LEN;
+ curPos += MP3_TAGv2_23_TXT_HEADER_LEN;
- if(oneFrameLen > MP3_TAGv2_23_TXT_HEADER_LEN && purelyFramelen <= taglen-curPos)
- {
+ if (oneFrameLen > MP3_TAGv2_23_TXT_HEADER_LEN && purelyFramelen <= taglen - curPos) {
curPos += purelyFramelen;
- if( IS_ENCODEDBY_UTF16(buffer+(curPos-purelyFramelen)) )
- {
+ if (IS_ENCODEDBY_UTF16(buffer + (curPos - purelyFramelen))) {
encodingOffSet = 2;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
+#endif
textEncodingType = AV_ID3V2_UTF16;
- }
- else if ( IS_ENCODEDBY_UTF16_R(buffer+(curPos-purelyFramelen)) )
- {
+ } else if (IS_ENCODEDBY_UTF16_R(buffer + (curPos - purelyFramelen))) {
encodingOffSet = 2;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
+#endif
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else if( IS_ENCODEDBY_UTF16(buffer+(curPos-purelyFramelen+1)) )
- {
+ } else if (IS_ENCODEDBY_UTF16(buffer + (curPos - purelyFramelen + 1))) {
encodingOffSet = 3;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
+#endif
textEncodingType = AV_ID3V2_UTF16;
- }
- else if ( IS_ENCODEDBY_UTF16_R(buffer+(curPos-purelyFramelen+1)) )
- {
+ } else if (IS_ENCODEDBY_UTF16_R(buffer + (curPos - purelyFramelen + 1))) {
encodingOffSet = 3;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
+#endif
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else
- {
- if (buffer[curPos-purelyFramelen+encodingOffSet] == 0x00)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("encodingOffset will be set to 1\n");
- #endif
-
- encodingOffSet=1;
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("Finding encodingOffset\n");
- #endif
+ } else {
+ if (buffer[curPos - purelyFramelen + encodingOffSet] == 0x00) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("encodingOffset will be set to 1\n");
+#endif
+
+ encodingOffSet = 1;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Finding encodingOffset\n");
+#endif
- while((buffer[curPos-purelyFramelen+encodingOffSet] < 0x20) && (encodingOffSet < purelyFramelen)) // text string encoded by ISO-8859-1
+ while ((buffer[curPos - purelyFramelen + encodingOffSet] < 0x20) && (encodingOffSet < purelyFramelen)) /* text string encoded by ISO-8859-1 */
encodingOffSet++;
}
textEncodingType = AV_ID3V2_ISO_8859;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "this text string(%s) encoded by ISO-8859-1 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("this text string(%s) encoded by ISO-8859-1 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
+#endif
}
- if(encodingOffSet < purelyFramelen)
- {
+ if (encodingOffSet < purelyFramelen) {
realCpyFrameNum = purelyFramelen - encodingOffSet;
- pExtContent = mmfile_malloc (realCpyFrameNum+3);
- memset(pExtContent, '\0', realCpyFrameNum+3);
+ pExtContent = mmfile_malloc(realCpyFrameNum + 3);
+ memset(pExtContent, '\0', realCpyFrameNum + 3);
if (textEncodingType != AV_ID3V2_UTF16 && textEncodingType != AV_ID3V2_UTF16_BE) {
- if (CompTmp[0] == 'T' ||(strcmp(CompTmp, "APIC")==0)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "get the new text ecoding type\n");
- #endif
- textEncodingType = buffer[curPos-purelyFramelen+encodingOffSet -1];
+ if (CompTmp[0] == 'T' || (strcmp(CompTmp, "APIC") == 0)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("get the new text ecoding type\n");
+#endif
+ textEncodingType = buffer[curPos - purelyFramelen + encodingOffSet - 1];
}
}
if (textEncodingType > AV_ID3V2_MAX) {
- debug_msg ( "WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char*)CompTmp);
+ debug_msg("WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char *)CompTmp);
continue;
}
- memcpy(pExtContent, &buffer[curPos-purelyFramelen+encodingOffSet], purelyFramelen-encodingOffSet);
- if(realCpyFrameNum > 0)
- {
- if(strncmp((char *)CompTmp, "TIT2", 4) == 0 && pInfo->tagV2Info.bTitleMarked == false)
- {
- pInfo->pTitle = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->titleLen);
+ memcpy(pExtContent, &buffer[curPos - purelyFramelen + encodingOffSet], purelyFramelen - encodingOffSet);
+ if (realCpyFrameNum > 0) {
+ if (strncmp((char *)CompTmp, "TIT2", 4) == 0 && pInfo->tagV2Info.bTitleMarked == false) {
+ pInfo->pTitle = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->titleLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
+#endif
pInfo->tagV2Info.bTitleMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TPE1", 4) == 0 && pInfo->tagV2Info.bArtistMarked == false)
- {
- pInfo->pArtist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->artistLen);
+ } else if (strncmp((char *)CompTmp, "TPE1", 4) == 0 && pInfo->tagV2Info.bArtistMarked == false) {
+ pInfo->pArtist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->artistLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
+#endif
pInfo->tagV2Info.bArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TPE2", 4) == 0 && pInfo->tagV2Info.bAlbum_ArtistMarked == false)
- {
- pInfo->pAlbum_Artist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->album_artistLen);
+ } else if (strncmp((char *)CompTmp, "TPE2", 4) == 0 && pInfo->tagV2Info.bAlbum_ArtistMarked == false) {
+ pInfo->pAlbum_Artist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->album_artistLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
+#endif
pInfo->tagV2Info.bAlbum_ArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TPE3", 4) == 0 && pInfo->tagV2Info.bConductorMarked == false)
- {
- pInfo->pConductor = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->conductorLen);
+ } else if (strncmp((char *)CompTmp, "TPE3", 4) == 0 && pInfo->tagV2Info.bConductorMarked == false) {
+ pInfo->pConductor = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->conductorLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
+#endif
pInfo->tagV2Info.bConductorMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TALB", 4) == 0 && pInfo->tagV2Info.bAlbumMarked == false)
- {
- pInfo->pAlbum = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->albumLen);
+ } else if (strncmp((char *)CompTmp, "TALB", 4) == 0 && pInfo->tagV2Info.bAlbumMarked == false) {
+ pInfo->pAlbum = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->albumLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
+#endif
pInfo->tagV2Info.bAlbumMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TYER", 4) == 0 && pInfo->tagV2Info.bYearMarked == false)
- {
- pInfo->pYear = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->yearLen);
+ } else if (strncmp((char *)CompTmp, "TYER", 4) == 0 && pInfo->tagV2Info.bYearMarked == false) {
+ pInfo->pYear = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->yearLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
+#endif
pInfo->tagV2Info.bYearMarked = true;
- }
- else if(strncmp((char *)CompTmp, "COMM", 4) == 0 && pInfo->tagV2Info.bDescriptionMarked == false)
- {
- if(realCpyFrameNum > 3)
- {
+ } else if (strncmp((char *)CompTmp, "COMM", 4) == 0 && pInfo->tagV2Info.bDescriptionMarked == false) {
+ if (realCpyFrameNum > 3) {
realCpyFrameNum -= 3;
tmp = 3;
- //pExtContent[tmp+1] value should't have encoding value
- if(pExtContent[tmp] == 0x00 || pExtContent[tmp] == 0xFF|| pExtContent[tmp] == 0xFE)
- {
- if((IS_ENCODEDBY_UTF16(pExtContent+tmp) || IS_ENCODEDBY_UTF16_R(pExtContent+tmp)) && realCpyFrameNum > 2)
- {
- while((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp))&& realCpyFrameNum > 4)
- {
+ /*pExtContent[tmp+1] value should't have encoding value */
+ if (pExtContent[tmp] == 0x00 || pExtContent[tmp] == 0xFF || pExtContent[tmp] == 0xFE) {
+ if ((IS_ENCODEDBY_UTF16(pExtContent + tmp) || IS_ENCODEDBY_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 2) {
+ while ((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp += 4;
}
- if(IS_ENCODEDBY_UTF16(pExtContent+tmp) && (realCpyFrameNum > 2))
- {
+ if (IS_ENCODEDBY_UTF16(pExtContent + tmp) && (realCpyFrameNum > 2)) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(pExtContent+tmp) && (realCpyFrameNum > 2))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(pExtContent + tmp) && (realCpyFrameNum > 2)) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else if(IS_ENCODEDBY_UTF16(pExtContent+tmp+1) && (realCpyFrameNum > 3))
- {
+ } else if (IS_ENCODEDBY_UTF16(pExtContent + tmp + 1) && (realCpyFrameNum > 3)) {
realCpyFrameNum -= 3;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(pExtContent+tmp+1) && (realCpyFrameNum > 3))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(pExtContent + tmp + 1) && (realCpyFrameNum > 3)) {
realCpyFrameNum -= 3;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16_BE;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment Never Get Here!!\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment Never Get Here!!\n");
- #endif
- }
- }
- else
- {
- while((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else {
+ while ((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_ISO_8859;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+#endif
- pInfo->pComment = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->commentLen);
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
- #endif
+ pInfo->pComment = mmfile_string_convert((const char *)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->commentLen);
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
+#endif
pInfo->commentLen = 0;
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
pInfo->commentLen = 0;
}
tmp = 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
+#endif
pInfo->tagV2Info.bDescriptionMarked = true;
- }
- else if(strncmp((char *)CompTmp, "SYLT", 4) == 0 && pInfo->tagV2Info.bSyncLyricsMarked == false)
- {
+ } else if (strncmp((char *)CompTmp, "SYLT", 4) == 0 && pInfo->tagV2Info.bSyncLyricsMarked == false) {
int idx = 0;
int copy_len = 0;
int copy_start_pos = tmp;
AvSynclyricsInfo *synclyrics_info = NULL;
GList *synclyrics_info_list = NULL;
-
- if(realCpyFrameNum > 5)
- {
+
+ if (realCpyFrameNum > 5) {
realCpyFrameNum -= 5;
tmp = 5;
- //pExtContent[tmp+1] value should't have encoding value
- if(pExtContent[tmp] == 0x00 || pExtContent[tmp] == 0xFF|| pExtContent[tmp] == 0xFE)
- {
- if((IS_ENCODEDBY_UTF16(pExtContent+tmp) || IS_ENCODEDBY_UTF16_R(pExtContent+tmp)) && realCpyFrameNum > 2)
- {
- while((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp))&& realCpyFrameNum > 4)
- {
+ /*pExtContent[tmp+1] value should't have encoding value */
+ if (pExtContent[tmp] == 0x00 || pExtContent[tmp] == 0xFF || pExtContent[tmp] == 0xFE) {
+ if ((IS_ENCODEDBY_UTF16(pExtContent + tmp) || IS_ENCODEDBY_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 2) {
+ while ((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp += 4;
}
- if(IS_ENCODEDBY_UTF16(pExtContent+tmp) && (realCpyFrameNum > 2))
- {
+ if (IS_ENCODEDBY_UTF16(pExtContent + tmp) && (realCpyFrameNum > 2)) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(pExtContent+tmp) && (realCpyFrameNum > 2))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(pExtContent + tmp) && (realCpyFrameNum > 2)) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else if(IS_ENCODEDBY_UTF16(pExtContent+tmp+1) && (realCpyFrameNum > 3))
- {
+ } else if (IS_ENCODEDBY_UTF16(pExtContent + tmp + 1) && (realCpyFrameNum > 3)) {
realCpyFrameNum -= 3;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(pExtContent+tmp+1) && (realCpyFrameNum > 3))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(pExtContent + tmp + 1) && (realCpyFrameNum > 3)) {
realCpyFrameNum -= 3;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16_BE;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pSyncLyrics Never Get Here!!\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pSyncLyrics Never Get Here!!\n");
- #endif
- }
- }
- else
- {
- while((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else {
+ while ((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_ISO_8859;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+#endif
- if(realCpyFrameNum < MMFILE_SYNC_LYRIC_INFO_MIN_LEN)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "failed to get Synchronised lyrics Info realCpyFramNum(%d)\n", realCpyFrameNum);
- #endif
+ if (realCpyFrameNum < MMFILE_SYNC_LYRIC_INFO_MIN_LEN) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("failed to get Synchronised lyrics Info realCpyFramNum(%d)\n", realCpyFrameNum);
+#endif
pInfo->syncLyricsNum = 0;
- }
- else
- {
- if(textEncodingType == AV_ID3V2_UTF16)
- {
- debug_warning ("[AV_ID3V2_UTF16] not implemented\n");
- }
- else if (textEncodingType == AV_ID3V2_UTF16_BE)
- {
- debug_warning ("[AV_ID3V2_UTF16_BE] not implemented\n");
- }
- else
- {
- for(idx = 0; idx < realCpyFrameNum; idx++)
- {
- if(pExtContent[tmp+idx] == 0x00)
- {
+ } else {
+ if (textEncodingType == AV_ID3V2_UTF16) {
+ debug_warning("[AV_ID3V2_UTF16] not implemented\n");
+ } else if (textEncodingType == AV_ID3V2_UTF16_BE) {
+ debug_warning("[AV_ID3V2_UTF16_BE] not implemented\n");
+ } else {
+ for (idx = 0; idx < realCpyFrameNum; idx++) {
+ if (pExtContent[tmp + idx] == 0x00) {
synclyrics_info = (AvSynclyricsInfo *)malloc(sizeof(AvSynclyricsInfo));
- if(synclyrics_info != NULL) {
- if(textEncodingType == AV_ID3V2_UTF8) {
- synclyrics_info->lyric_info= mmfile_malloc(copy_len+1);
- if(synclyrics_info->lyric_info != NULL) {
- memset(synclyrics_info->lyric_info, 0, copy_len+1);
- memcpy(synclyrics_info->lyric_info, pExtContent+copy_start_pos, copy_len);
- synclyrics_info->lyric_info[copy_len+1] = '\0';
+ if (synclyrics_info != NULL) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ synclyrics_info->lyric_info = mmfile_malloc(copy_len + 1);
+ if (synclyrics_info->lyric_info != NULL) {
+ memset(synclyrics_info->lyric_info, 0, copy_len + 1);
+ memcpy(synclyrics_info->lyric_info, pExtContent + copy_start_pos, copy_len);
+ synclyrics_info->lyric_info[copy_len + 1] = '\0';
}
- }
- else {
- synclyrics_info->lyric_info = mmfile_string_convert ((const char*)&pExtContent[copy_start_pos], copy_len, "UTF-8", charset_array[AV_ID3V2_ISO_8859], NULL, NULL);
+ } else {
+ synclyrics_info->lyric_info = mmfile_string_convert((const char *)&pExtContent[copy_start_pos], copy_len, "UTF-8", charset_array[AV_ID3V2_ISO_8859], NULL, NULL);
}
- synclyrics_info->time_info= (unsigned long)pExtContent[tmp+idx+1] << 24 | (unsigned long)pExtContent[tmp+idx+2] << 16 | (unsigned long)pExtContent[tmp+idx+3] << 8 | (unsigned long)pExtContent[tmp+idx+4];
+ synclyrics_info->time_info = (unsigned long)pExtContent[tmp + idx + 1] << 24 | (unsigned long)pExtContent[tmp + idx + 2] << 16 | (unsigned long)pExtContent[tmp + idx + 3] << 8 | (unsigned long)pExtContent[tmp + idx + 4];
idx += 4;
copy_start_pos = tmp + idx + 1;
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("[%d][%s] idx[%d], copy_len[%d] copy_start_pos[%d]", synclyrics_info->time_info, synclyrics_info->lyric_info, idx, copy_len, copy_start_pos);
- #endif
+#endif
copy_len = 0;
synclyrics_info_list = g_list_append(synclyrics_info_list, synclyrics_info);
}
}
- copy_len ++;
+ copy_len++;
}
pInfo->pSyncLyrics = synclyrics_info_list;
pInfo->syncLyricsNum = g_list_length(pInfo->pSyncLyrics);
}
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "failed to get Synchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("failed to get Synchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
+#endif
pInfo->syncLyricsNum = 0;
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Synchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Synchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
pInfo->syncLyricsNum = 0;
}
tmp = 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pSyncLyrics returned = (%s), pInfo->syncLyricsNum(%d)\n", pInfo->pSyncLyrics, pInfo->syncLyricsNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pSyncLyrics returned = (%s), pInfo->syncLyricsNum(%d)\n", pInfo->pSyncLyrics, pInfo->syncLyricsNum);
+#endif
pInfo->tagV2Info.bSyncLyricsMarked = true;
- }
- else if(strncmp((char *)CompTmp, "USLT", 4) == 0 && pInfo->tagV2Info.bUnsyncLyricsMarked == false)
- {
- char *lang_info = strndup((char*)pExtContent, 3);
+ } else if (strncmp((char *)CompTmp, "USLT", 4) == 0 && pInfo->tagV2Info.bUnsyncLyricsMarked == false) {
+ char *lang_info = strndup((char *)pExtContent, 3);
- if(realCpyFrameNum > 3)
- {
+ if (realCpyFrameNum > 3) {
realCpyFrameNum -= 3;
tmp = 3;
/*find start of lyrics */
- while(1) {
+ while (1) {
if (pExtContent[tmp] == 0x00) {
- if (pExtContent[tmp+1] == 0x00) {
- realCpyFrameNum -=2;
- tmp +=2;
+ if (pExtContent[tmp + 1] == 0x00) {
+ realCpyFrameNum -= 2;
+ tmp += 2;
}
break;
} else {
}
}
- //pExtContent[tmp+1] value should't have encoding value
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tpExtContent[%d] %x\n", tmp, pExtContent[tmp]);
- #endif
- if(pExtContent[tmp] == 0x00 || pExtContent[tmp] == 0xFF|| pExtContent[tmp] == 0xFE)
- {
- if((IS_ENCODEDBY_UTF16(pExtContent+tmp) || IS_ENCODEDBY_UTF16_R(pExtContent+tmp)) && realCpyFrameNum > 2)
- {
- while((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp))&& realCpyFrameNum > 4)
- {
+ /*pExtContent[tmp+1] value should't have encoding value */
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tpExtContent[%d] %x\n", tmp, pExtContent[tmp]);
+#endif
+ if (pExtContent[tmp] == 0x00 || pExtContent[tmp] == 0xFF || pExtContent[tmp] == 0xFE) {
+ if ((IS_ENCODEDBY_UTF16(pExtContent + tmp) || IS_ENCODEDBY_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 2) {
+ while ((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp += 4;
}
- if(IS_ENCODEDBY_UTF16(pExtContent+tmp) && (realCpyFrameNum > 2))
- {
+ if (IS_ENCODEDBY_UTF16(pExtContent + tmp) && (realCpyFrameNum > 2)) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(pExtContent+tmp) && (realCpyFrameNum > 2))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(pExtContent + tmp) && (realCpyFrameNum > 2)) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else if(IS_ENCODEDBY_UTF16(pExtContent+tmp+1) && (realCpyFrameNum > 3))
- {
+ } else if (IS_ENCODEDBY_UTF16(pExtContent + tmp + 1) && (realCpyFrameNum > 3)) {
realCpyFrameNum -= 3;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(pExtContent+tmp+1) && (realCpyFrameNum > 3))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(pExtContent + tmp + 1) && (realCpyFrameNum > 3)) {
realCpyFrameNum -= 3;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16_BE;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pUnsyncLyrics Never Get Here!!\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pUnsyncLyrics Never Get Here!!\n");
- #endif
- }
- }
- else
- {
- while((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else {
+ while ((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_ISO_8859;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+#endif
char *char_set = NULL;
if (textEncodingType == AV_ID3V2_ISO_8859) {
if (lang_info != NULL && !strcasecmp(lang_info, "KOR")) {
char_set = strdup("EUC-KR");
} else {
- char_set = mmfile_get_charset((const char*)&pExtContent[tmp]);
+ char_set = mmfile_get_charset((const char *)&pExtContent[tmp]);
}
_FREE_EX(lang_info);
}
if (char_set == NULL) {
- pInfo->pUnsyncLyrics = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->unsynclyricsLen);
+ pInfo->pUnsyncLyrics = mmfile_string_convert((const char *)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->unsynclyricsLen);
} else {
- pInfo->pUnsyncLyrics = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", char_set, NULL, (unsigned int*)&pInfo->unsynclyricsLen);
+ pInfo->pUnsyncLyrics = mmfile_string_convert((const char *)&pExtContent[tmp], realCpyFrameNum, "UTF-8", char_set, NULL, (unsigned int *)&pInfo->unsynclyricsLen);
_FREE_EX(char_set);
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "failed to get Unsynchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("failed to get Unsynchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
+#endif
pInfo->unsynclyricsLen = 0;
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Unsynchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Unsynchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
pInfo->unsynclyricsLen = 0;
}
tmp = 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
+#endif
pInfo->tagV2Info.bUnsyncLyricsMarked = true;
mmfile_free(lang_info);
- }
- else if(strncmp((char *)CompTmp, "TCON", 4) == 0 && pInfo->tagV2Info.bGenreMarked == false)
- {
- pInfo->pGenre = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->genreLen);
+ } else if (strncmp((char *)CompTmp, "TCON", 4) == 0 && pInfo->tagV2Info.bGenreMarked == false) {
+ pInfo->pGenre = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->genreLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
+#endif
- if((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
+ if ((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
bool ret = FALSE;
int int_genre = -1;
ret = is_numeric(pInfo->pGenre, pInfo->genreLen);
- if(ret == TRUE) {
- sscanf( pInfo->pGenre, "%d", &int_genre);
- #ifdef __MMFILE_TEST_MODE__
+ if (ret == TRUE) {
+ sscanf(pInfo->pGenre, "%d", &int_genre);
+#ifdef __MMFILE_TEST_MODE__
debug_msg("genre information is inteager [%d]\n", int_genre);
- #endif
+#endif
- //Change int to string
- if((0 <= int_genre) && (int_genre < GENRE_COUNT-1)) {
+ /*Change int to string */
+ if ((0 <= int_genre) && (int_genre < GENRE_COUNT - 1)) {
/*save genreinfo like "(123)". mm_file_id3tag_restore_content_info convert it to string*/
- char tmp_genre[6] = {0,}; /*ex. "(123)+NULL"*/
+ char tmp_genre[6] = {0, }; /*ex. "(123)+NULL"*/
int tmp_genre_len = 0;
- memset (tmp_genre, 0, 6);
+ memset(tmp_genre, 0, 6);
snprintf(tmp_genre, sizeof(tmp_genre), "(%d)", int_genre);
tmp_genre_len = strlen(tmp_genre);
- if(tmp_genre_len > 0) {
- if(pInfo->pGenre) _FREE_EX(pInfo->pGenre);
- pInfo->pGenre = mmfile_malloc (sizeof(char) * (tmp_genre_len + 1) );
- if (pInfo->pGenre)
- {
+ if (tmp_genre_len > 0) {
+ if (pInfo->pGenre) _FREE_EX(pInfo->pGenre);
+ pInfo->pGenre = mmfile_malloc(sizeof(char) * (tmp_genre_len + 1));
+ if (pInfo->pGenre) {
strncpy(pInfo->pGenre, tmp_genre, tmp_genre_len);
pInfo->pGenre[tmp_genre_len] = 0;
}
}
pInfo->tagV2Info.bGenreMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TRCK", 4) == 0 && pInfo->tagV2Info.bTrackNumMarked == false)
- {
- pInfo->pTrackNum = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->tracknumLen);
+ } else if (strncmp((char *)CompTmp, "TRCK", 4) == 0 && pInfo->tagV2Info.bTrackNumMarked == false) {
+ pInfo->pTrackNum = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->tracknumLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
+#endif
pInfo->tagV2Info.bTrackNumMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TENC", 4) == 0 && pInfo->tagV2Info.bEncByMarked == false)
- {
- pInfo->pEncBy = mmfile_string_convert ((char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->encbyLen);
+ } else if (strncmp((char *)CompTmp, "TENC", 4) == 0 && pInfo->tagV2Info.bEncByMarked == false) {
+ pInfo->pEncBy = mmfile_string_convert((char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->encbyLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
+#endif
pInfo->tagV2Info.bEncByMarked = true;
- }
- else if(strncmp((char *)CompTmp, "WXXX", 4) == 0 && pInfo->tagV2Info.bURLMarked == false)
- {
- pInfo->pURL = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->urlLen);
+ } else if (strncmp((char *)CompTmp, "WXXX", 4) == 0 && pInfo->tagV2Info.bURLMarked == false) {
+ pInfo->pURL = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->urlLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
+#endif
pInfo->tagV2Info.bURLMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TCOP", 4) == 0 && pInfo->tagV2Info.bCopyRightMarked == false)
- {
- pInfo->pCopyright = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->copyrightLen);
+ } else if (strncmp((char *)CompTmp, "TCOP", 4) == 0 && pInfo->tagV2Info.bCopyRightMarked == false) {
+ pInfo->pCopyright = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->copyrightLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
+#endif
pInfo->tagV2Info.bCopyRightMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TOPE", 4) == 0 && pInfo->tagV2Info.bOriginArtistMarked == false)
- {
- pInfo->pOriginArtist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->originartistLen);
+ } else if (strncmp((char *)CompTmp, "TOPE", 4) == 0 && pInfo->tagV2Info.bOriginArtistMarked == false) {
+ pInfo->pOriginArtist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->originartistLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
+#endif
pInfo->tagV2Info.bOriginArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TCOM", 4) == 0 && pInfo->tagV2Info.bComposerMarked == false)
- {
- pInfo->pComposer = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->composerLen);
+ } else if (strncmp((char *)CompTmp, "TCOM", 4) == 0 && pInfo->tagV2Info.bComposerMarked == false) {
+ pInfo->pComposer = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->composerLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComposer returned = (%s), pInfo->composerLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComposer returned = (%s), pInfo->composerLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
+#endif
pInfo->tagV2Info.bComposerMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TRDA", 4) == 0 && pInfo->tagV2Info.bRecDateMarked== false)
- {
- pInfo->pRecDate = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->recdateLen);
+ } else if (strncmp((char *)CompTmp, "TRDA", 4) == 0 && pInfo->tagV2Info.bRecDateMarked == false) {
+ pInfo->pRecDate = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->recdateLen);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
+#endif
pInfo->tagV2Info.bRecDateMarked = true;
- }
- else if(strncmp((char *)CompTmp, "APIC", 4) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000)
- {
- debug_msg ( "text encoding %d \n", textEncodingType);
+ } else if (strncmp((char *)CompTmp, "APIC", 4) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000) {
+ debug_msg("text encoding %d \n", textEncodingType);
- if(pExtContent[0] != '\0')
- {
- for(inx = 0; inx < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH-1; inx++)
- pInfo->imageInfo.imageMIMEType[inx] = '\0';//ini mimetype variable
+ if (pExtContent[0] != '\0') {
+ for (inx = 0; inx < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH - 1; inx++)
+ pInfo->imageInfo.imageMIMEType[inx] = '\0';/*ini mimetype variable */
- while((checkImgMimeTypeMax < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH-1) && pExtContent[checkImgMimeTypeMax] != '\0')
- {
+ while ((checkImgMimeTypeMax < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH - 1) && pExtContent[checkImgMimeTypeMax] != '\0') {
pInfo->imageInfo.imageMIMEType[checkImgMimeTypeMax] = pExtContent[checkImgMimeTypeMax];
checkImgMimeTypeMax++;
}
pInfo->imageInfo.imgMimetypeLen = checkImgMimeTypeMax;
- }
- else
- {
+ } else {
pInfo->imageInfo.imgMimetypeLen = 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "APIC image's not included to MIME type\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("APIC image's not included to MIME type\n");
+#endif
}
imgstartOffset += checkImgMimeTypeMax;
continue;
}
- if((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0))
- {
- imgstartOffset++;//endofMIME(1byte)
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "after scaning Mime type imgstartOffset(%d) value!\n", imgstartOffset);
- #endif
+ if ((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0)) {
+ imgstartOffset++;/*endofMIME(1byte) */
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("after scaning Mime type imgstartOffset(%d) value!\n", imgstartOffset);
+#endif
- if(pExtContent[imgstartOffset] < AV_ID3V2_PICTURE_TYPE_MAX)
- {
+ if (pExtContent[imgstartOffset] < AV_ID3V2_PICTURE_TYPE_MAX) {
pInfo->imageInfo.pictureType = pExtContent[imgstartOffset];
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("APIC image has invalid picture type(0x%x)\n", pExtContent[imgstartOffset]);
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "APIC image has invalid picture type(0x%x)\n", pExtContent[imgstartOffset]);
- #endif
- }
- imgstartOffset++;//PictureType(1byte)
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "after scaning PictureType imgstartOffset(%d) value!\n", imgstartOffset);
- #endif
+ imgstartOffset++;/*PictureType(1byte) */
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("after scaning PictureType imgstartOffset(%d) value!\n", imgstartOffset);
+#endif
- if(pExtContent[imgstartOffset] != 0x0)
- {
+ if (pExtContent[imgstartOffset] != 0x0) {
int cur_pos = 0;
int dis_len = 0;
int new_dis_len = 0;
char jpg_sign[3] = {0xff, 0xd8, 0xff};
- char png_sign[8] = {0x80, 0x50, 0x4e, 0x47,0x0d, 0x0a, 0x1a, 0x0a};
+ char png_sign[8] = {0x80, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
char *tmp_desc = NULL;
while (1) {
}
/*check end of image description*/
if ((pExtContent[imgstartOffset + cur_pos + 1] == jpg_sign[0]) ||
- (pExtContent[imgstartOffset + cur_pos + 1] == png_sign[0])) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "length of description (%d)", cur_pos);
- #endif
+ (pExtContent[imgstartOffset + cur_pos + 1] == png_sign[0])) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("length of description (%d)", cur_pos);
+#endif
break;
}
}
- cur_pos ++;
+ cur_pos++;
}
dis_len = cur_pos + 1;
memcpy(tmp_desc, pExtContent + imgstartOffset, dis_len);
/*convert description*/
- pInfo->imageInfo.imageDescription = mmfile_string_convert (tmp_desc, dis_len, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&new_dis_len);
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
- #endif
+ pInfo->imageInfo.imageDescription = mmfile_string_convert(tmp_desc, dis_len, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&new_dis_len);
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
+#endif
mmfile_free(tmp_desc);
pInfo->imageInfo.imgDesLen = new_dis_len; /**/
imgstartOffset += cur_pos;
- }
- else
- {
- pInfo->imageInfo.imgDesLen= 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "APIC image's not included to Description!!!\n");
- #endif
+ } else {
+ pInfo->imageInfo.imgDesLen = 0;
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("APIC image's not included to Description!!!\n");
+#endif
}
- if((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0))
- {
- imgstartOffset ++; // endofDesceriptionType(1byte)
+ if ((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0)) {
+ imgstartOffset++; /* endofDesceriptionType(1byte) */
- while(pExtContent[imgstartOffset] == '\0') //some content has useless '\0' in front of picture data
- {
- imgstartOffset ++;
+ while (pExtContent[imgstartOffset] == '\0') { /*some content has useless '\0' in front of picture data */
+ imgstartOffset++;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
+#endif
- if(realCpyFrameNum - imgstartOffset > 0)
- {
+ if (realCpyFrameNum - imgstartOffset > 0) {
pInfo->imageInfo.imageLen = realCpyFrameNum - imgstartOffset;
- pInfo->imageInfo.pImageBuf = mmfile_malloc (pInfo->imageInfo.imageLen + 1);
+ pInfo->imageInfo.pImageBuf = mmfile_malloc(pInfo->imageInfo.imageLen + 1);
- if(pInfo->imageInfo.pImageBuf != NULL ) {
- memcpy(pInfo->imageInfo.pImageBuf, pExtContent+ imgstartOffset, pInfo->imageInfo.imageLen);
+ if (pInfo->imageInfo.pImageBuf != NULL) {
+ memcpy(pInfo->imageInfo.pImageBuf, pExtContent + imgstartOffset, pInfo->imageInfo.imageLen);
pInfo->imageInfo.pImageBuf[pInfo->imageInfo.imageLen] = 0;
}
- if(IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
- pInfo->imageInfo.bURLInfo = true; //if mimetype is "-->", image date has an URL
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
- #endif
+ if (IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
+ pInfo->imageInfo.bURLInfo = true; /*if mimetype is "-->", image date has an URL */
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
+#endif
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->imageInfo.imageLen(%d), imgstartOffset(%d)!\n", pInfo->imageInfo.imageLen, imgstartOffset);
- #endif
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pExtContent[imgstartOffset](%d) value should setted NULL value for end of description! realCpyFrameNum - imgstartOffset(%d)\n",
- pExtContent[imgstartOffset], realCpyFrameNum - imgstartOffset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->imageInfo.imageLen(%d), imgstartOffset(%d)!\n", pInfo->imageInfo.imageLen, imgstartOffset);
+#endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pExtContent[imgstartOffset](%d) value should setted NULL value for end of description! realCpyFrameNum - imgstartOffset(%d)\n",
+ pExtContent[imgstartOffset], realCpyFrameNum - imgstartOffset);
+#endif
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pExtContent[imgstartOffset](%d) value should setted NULL value for end of mimetype! realCpyFrameNum - imgstartOffset(%d)\n",
- pExtContent[imgstartOffset], realCpyFrameNum - imgstartOffset);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pExtContent[imgstartOffset](%d) value should setted NULL value for end of mimetype! realCpyFrameNum - imgstartOffset(%d)\n",
+ pExtContent[imgstartOffset], realCpyFrameNum - imgstartOffset);
+#endif
}
checkImgMimeTypeMax = 0;
inx = 0;
imgstartOffset = 0;
- pInfo->tagV2Info.bImageMarked= true;
+ pInfo->tagV2Info.bImageMarked = true;
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
+#endif
}
}
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("All of the pExtContent Values are NULL\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "All of the pExtContent Values are NULL\n");
- #endif
- }
- }
- else
- {
+ } else {
curPos += purelyFramelen;
- if(purelyFramelen != 0)
+ if (purelyFramelen != 0)
needToloopv2taglen = MP3_TAGv2_23_TXT_HEADER_LEN;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "This Frame's size is Zero! purelyFramelen(%d)\n", purelyFramelen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("This Frame's size is Zero! purelyFramelen(%d)\n", purelyFramelen);
+#endif
}
- if(pExtContent) _FREE_EX(pExtContent);
+ if (pExtContent) _FREE_EX(pExtContent);
memset(CompTmp, 0, 4);
- if(curPos < taglen)
- {
+ if (curPos < taglen) {
needToloopv2taglen -= oneFrameLen;
v2numOfFrames++;
- }
- else
+ } else
needToloopv2taglen = MP3_TAGv2_23_TXT_HEADER_LEN;
oneFrameLen = 0;
encodingOffSet = 0;
release_characterset_array(charset_array);
- if(taglen)
+ if (taglen)
return true;
else
return false;
}
EXPORT_API
-bool mm_file_id3tag_parse_v224(AvFileContentInfo* pInfo, unsigned char *buffer)
+bool mm_file_id3tag_parse_v224(AvFileContentInfo *pInfo, unsigned char *buffer)
{
unsigned long taglen = 0;
unsigned long needToloopv2taglen;
char CompTmp[5];
unsigned char *pExtContent = NULL;
unsigned long purelyFramelen = 0;
- int inx=0, encodingOffSet=0, realCpyFrameNum=0, checkImgMimeTypeMax=0, imgstartOffset=0, tmp = 0;
+ unsigned int encodingOffSet = 0;
+ int inx = 0, realCpyFrameNum = 0, checkImgMimeTypeMax = 0, imgstartOffset = 0, tmp = 0;
int textEncodingType = 0;
char **charset_array = NULL;
- char *MIME_PRFIX = "image/";
+ const char *MIME_PRFIX = "image/";
make_characterset_array(&charset_array);
curPos = MP3_TAGv2_HEADER_LEN;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("ID3tag v224--------------------------------------------------------------\n");
+ debug_msg("ID3tag v224--------------------------------------------------------------\n");
#endif
/* check Extended Header */
- if (buffer[5] & 0x40)
- {
+ if (buffer[5] & 0x40) {
/* if extended header exists, skip it*/
int extendedHeaderLen = (unsigned long)buffer[10] << 21 | (unsigned long)buffer[11] << 14 | (unsigned long)buffer[12] << 7 | (unsigned long)buffer[13];
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("--------------- extendedHeaderLen = %d\n", extendedHeaderLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("--------------- extendedHeaderLen = %d\n", extendedHeaderLen);
+#endif
curPos += extendedHeaderLen;
}
- if(needToloopv2taglen -MP3_TAGv2_23_TXT_HEADER_LEN > MP3_TAGv2_23_TXT_HEADER_LEN)
- {
+ if (needToloopv2taglen - MP3_TAGv2_23_TXT_HEADER_LEN > MP3_TAGv2_23_TXT_HEADER_LEN) {
v2numOfFrames = 1;
- while(needToloopv2taglen > MP3_TAGv2_23_TXT_HEADER_LEN)
- {
- if((buffer[curPos] < '0' || buffer[curPos] > 'Z') || (buffer[curPos+1] < '0' || buffer[curPos+1] > 'Z')
- || (buffer[curPos+2] < '0' || buffer[curPos+2] > 'Z')|| (buffer[curPos+3] < '0' || buffer[curPos+3] > 'Z'))
+ while (needToloopv2taglen > MP3_TAGv2_23_TXT_HEADER_LEN) {
+ if ((buffer[curPos] < '0' || buffer[curPos] > 'Z') || (buffer[curPos + 1] < '0' || buffer[curPos + 1] > 'Z')
+ || (buffer[curPos + 2] < '0' || buffer[curPos + 2] > 'Z') || (buffer[curPos + 3] < '0' || buffer[curPos + 3] > 'Z'))
break;
memcpy(CompTmp, &buffer[curPos], 4);
CompTmp[4] = 0;
oneFrameLen = MP3_TAGv2_23_TXT_HEADER_LEN;
- oneFrameLen += (unsigned long)buffer[4+curPos] << 21 | (unsigned long)buffer[5+curPos] << 14
- | (unsigned long)buffer[6+curPos] << 7 | (unsigned long)buffer[7+curPos];
- if(oneFrameLen > taglen-curPos)
+ oneFrameLen += (unsigned long)buffer[4 + curPos] << 21 | (unsigned long)buffer[5 + curPos] << 14
+ | (unsigned long)buffer[6 + curPos] << 7 | (unsigned long)buffer[7 + curPos];
+ if (oneFrameLen > taglen - curPos)
break;
purelyFramelen = oneFrameLen - MP3_TAGv2_23_TXT_HEADER_LEN;
- curPos +=MP3_TAGv2_23_TXT_HEADER_LEN;
+ curPos += MP3_TAGv2_23_TXT_HEADER_LEN;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("-----------------------------------------------------------------------------------\n");
+ debug_msg("-----------------------------------------------------------------------------------\n");
#endif
- if(oneFrameLen > MP3_TAGv2_23_TXT_HEADER_LEN && purelyFramelen <= taglen-curPos)
- {
+ if (oneFrameLen > MP3_TAGv2_23_TXT_HEADER_LEN && purelyFramelen <= taglen - curPos) {
curPos += purelyFramelen;
- //in case of UTF 16 encoding
- //buffer+(curPos-purelyFramelen) data should '0x01' but in order to expansion, we don't accurately check the value.
- if(IS_ENCODEDBY_UTF16(buffer+(curPos-purelyFramelen)))
- {
+ /*in case of UTF 16 encoding */
+ /*buffer+(curPos-purelyFramelen) data should '0x01' but in order to expansion, we don't accurately check the value. */
+ if (IS_ENCODEDBY_UTF16(buffer + (curPos - purelyFramelen))) {
encodingOffSet = 2;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if (IS_ENCODEDBY_UTF16_R(buffer+(curPos-purelyFramelen)))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(buffer + (curPos - purelyFramelen))) {
encodingOffSet = 2;
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else if(IS_ENCODEDBY_UTF16(buffer+(curPos-purelyFramelen+1)))
- {
+ } else if (IS_ENCODEDBY_UTF16(buffer + (curPos - purelyFramelen + 1))) {
encodingOffSet = 3;
textEncodingType = AV_ID3V2_UTF16;
- }
- else if(IS_ENCODEDBY_UTF16_R(buffer+(curPos-purelyFramelen+1)))
- {
+ } else if (IS_ENCODEDBY_UTF16_R(buffer + (curPos - purelyFramelen + 1))) {
encodingOffSet = 3;
textEncodingType = AV_ID3V2_UTF16_BE;
- }
- else
- {
- //in case of UTF-16 BE encoding
- if(buffer[curPos-purelyFramelen] == 0x02)
- {
+ } else {
+ /*in case of UTF-16 BE encoding */
+ if (buffer[curPos - purelyFramelen] == 0x02) {
encodingOffSet = 1;
- while((buffer[curPos-purelyFramelen+encodingOffSet] == '\0') && (encodingOffSet < purelyFramelen))
- encodingOffSet++;//null skip!
+ while ((buffer[curPos - purelyFramelen + encodingOffSet] == '\0') && (encodingOffSet < purelyFramelen))
+ encodingOffSet++;/*null skip! */
textEncodingType = AV_ID3V2_UTF16_BE;
}
- //in case of UTF8 encoding
- else if (buffer[curPos-purelyFramelen] == 0x03)
- {
+ /*in case of UTF8 encoding */
+ else if (buffer[curPos - purelyFramelen] == 0x03) {
encodingOffSet = 1;
- while((buffer[curPos-purelyFramelen+encodingOffSet] == '\0') && (encodingOffSet < purelyFramelen))
- encodingOffSet++;//null skip!
+ while ((buffer[curPos - purelyFramelen + encodingOffSet] == '\0') && (encodingOffSet < purelyFramelen))
+ encodingOffSet++;/*null skip! */
textEncodingType = AV_ID3V2_UTF8;
}
- //in case of ISO-8859-1 encoding
- else
- {
- //buffer+(curPos-purelyFramelen) data should 0x00 but in order to expansion, we don't accurately check the value.
+ /*in case of ISO-8859-1 encoding */
+ else {
+ /*buffer+(curPos-purelyFramelen) data should 0x00 but in order to expansion, we don't accurately check the value. */
encodingOffSet = 1;
- while((buffer[curPos-purelyFramelen+encodingOffSet] < 0x20) && (encodingOffSet < purelyFramelen))
- encodingOffSet++;//less than 0x20 value skip!
+ while ((buffer[curPos - purelyFramelen + encodingOffSet] < 0x20) && (encodingOffSet < purelyFramelen))
+ encodingOffSet++;/*less than 0x20 value skip! */
textEncodingType = AV_ID3V2_ISO_8859;
}
}
- if(encodingOffSet < purelyFramelen)
- {
+ if (encodingOffSet < purelyFramelen) {
realCpyFrameNum = purelyFramelen - encodingOffSet;
- pExtContent = mmfile_malloc (realCpyFrameNum+3);
- memset(pExtContent, '\0', realCpyFrameNum+3);
+ pExtContent = mmfile_malloc(realCpyFrameNum + 3);
+ memset(pExtContent, '\0', realCpyFrameNum + 3);
if (textEncodingType != AV_ID3V2_UTF16 && textEncodingType != AV_ID3V2_UTF16_BE) {
- if (CompTmp[0] == 'T' ||(strcmp(CompTmp, "APIC")==0)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "get the new text ecoding type\n");
- #endif
- textEncodingType = buffer[curPos-purelyFramelen+encodingOffSet -1];
+ if (CompTmp[0] == 'T' || (strcmp(CompTmp, "APIC") == 0)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("get the new text ecoding type\n");
+#endif
+ textEncodingType = buffer[curPos - purelyFramelen + encodingOffSet - 1];
}
}
if (textEncodingType > AV_ID3V2_MAX) {
- debug_msg ( "WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char*)CompTmp);
+ debug_msg("WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char *)CompTmp);
continue;
}
- memcpy(pExtContent, &buffer[curPos-purelyFramelen+encodingOffSet], purelyFramelen-encodingOffSet);
+ memcpy(pExtContent, &buffer[curPos - purelyFramelen + encodingOffSet], purelyFramelen - encodingOffSet);
- if(realCpyFrameNum > 0)
- {
- if(strncmp((char *)CompTmp, "TIT2", 4) == 0 && pInfo->tagV2Info.bTitleMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pTitle= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ if (realCpyFrameNum > 0) {
+ if (strncmp((char *)CompTmp, "TIT2", 4) == 0 && pInfo->tagV2Info.bTitleMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pTitle = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pTitle, pExtContent, realCpyFrameNum);
pInfo->pTitle[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->titleLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pTitle, pExtContent, pInfo->titleLen);
- }
- else
- {
- pInfo->pTitle = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->titleLen);
+ _STRNCPY_EX(pInfo->pTitle, pExtContent, pInfo->titleLen);
+ } else {
+ pInfo->pTitle = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->titleLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
+#endif
pInfo->tagV2Info.bTitleMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TPE1", 4) == 0 && pInfo->tagV2Info.bArtistMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pArtist= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TPE1", 4) == 0 && pInfo->tagV2Info.bArtistMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pArtist = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pArtist, pExtContent, realCpyFrameNum);
pInfo->pArtist[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->artistLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pArtist, pExtContent, pInfo->artistLen);
- }
- else
- {
- pInfo->pArtist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->artistLen);
+ _STRNCPY_EX(pInfo->pArtist, pExtContent, pInfo->artistLen);
+ } else {
+ pInfo->pArtist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->artistLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
+#endif
pInfo->tagV2Info.bArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TPE2", 4) == 0 && pInfo->tagV2Info.bAlbum_ArtistMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pAlbum_Artist= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TPE2", 4) == 0 && pInfo->tagV2Info.bAlbum_ArtistMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pAlbum_Artist = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pAlbum_Artist, pExtContent, realCpyFrameNum);
pInfo->pAlbum_Artist[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->album_artistLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pAlbum_Artist, pExtContent, pInfo->album_artistLen);
- }
- else
- {
- pInfo->pAlbum_Artist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->album_artistLen);
+ _STRNCPY_EX(pInfo->pAlbum_Artist, pExtContent, pInfo->album_artistLen);
+ } else {
+ pInfo->pAlbum_Artist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->album_artistLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
+#endif
pInfo->tagV2Info.bAlbum_ArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TPE3", 4) == 0 && pInfo->tagV2Info.bConductorMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pConductor= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TPE3", 4) == 0 && pInfo->tagV2Info.bConductorMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pConductor = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pConductor, pExtContent, realCpyFrameNum);
pInfo->pConductor[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->conductorLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pConductor, pExtContent, pInfo->conductorLen);
- }
- else
- {
- pInfo->pConductor = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->conductorLen);
+ _STRNCPY_EX(pInfo->pConductor, pExtContent, pInfo->conductorLen);
+ } else {
+ pInfo->pConductor = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->conductorLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
+#endif
pInfo->tagV2Info.bConductorMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TALB", 4) == 0 && pInfo->tagV2Info.bAlbumMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pAlbum= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TALB", 4) == 0 && pInfo->tagV2Info.bAlbumMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pAlbum = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pAlbum, pExtContent, realCpyFrameNum);
pInfo->pAlbum[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->albumLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pAlbum, pExtContent, pInfo->albumLen);
- }
- else
- {
- pInfo->pAlbum = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->albumLen);
+ _STRNCPY_EX(pInfo->pAlbum, pExtContent, pInfo->albumLen);
+ } else {
+ pInfo->pAlbum = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->albumLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
+#endif
pInfo->tagV2Info.bAlbumMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TYER", 4) == 0 && pInfo->tagV2Info.bYearMarked == false) //TODO. TYER is replaced by the TDRC. but many files use TYER in v2.4
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pYear= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TYER", 4) == 0 && pInfo->tagV2Info.bYearMarked == false) { /*TODO. TYER is replaced by the TDRC. but many files use TYER in v2.4 */
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pYear = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pYear, pExtContent, realCpyFrameNum);
pInfo->pYear[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->yearLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pYear, pExtContent, pInfo->yearLen);
- }
- else
- {
- pInfo->pYear = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->yearLen);
+ _STRNCPY_EX(pInfo->pYear, pExtContent, pInfo->yearLen);
+ } else {
+ pInfo->pYear = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->yearLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
+#endif
pInfo->tagV2Info.bYearMarked = true;
- }
- else if(strncmp((char *)CompTmp, "COMM", 4) == 0 && pInfo->tagV2Info.bDescriptionMarked == false)
- {
- if(realCpyFrameNum > 3)
- {
+ } else if (strncmp((char *)CompTmp, "COMM", 4) == 0 && pInfo->tagV2Info.bDescriptionMarked == false) {
+ if (realCpyFrameNum > 3) {
realCpyFrameNum -= 3;
tmp = 3;
- if(textEncodingType == AV_ID3V2_UTF16 || textEncodingType == AV_ID3V2_UTF16_BE)
- {
- while((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp))&& realCpyFrameNum > 4)
- {
+ if (textEncodingType == AV_ID3V2_UTF16 || textEncodingType == AV_ID3V2_UTF16_BE) {
+ while ((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp += 4;
}
- if((IS_ENCODEDBY_UTF16(pExtContent+tmp) || IS_ENCODEDBY_UTF16_R(pExtContent+tmp)) && realCpyFrameNum > 2)
- {
+ if ((IS_ENCODEDBY_UTF16(pExtContent + tmp) || IS_ENCODEDBY_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 2) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment Never Get Here!!\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment Never Get Here!!\n");
- #endif
- }
- }
- else if(textEncodingType == AV_ID3V2_UTF8)
- {
- while(pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else if (textEncodingType == AV_ID3V2_UTF8) {
+ while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_UTF8;
- }
- else
- {
- while(pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else {
+ while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_ISO_8859;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+#endif
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pComment= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
- memset(pInfo->pComment, 0, (realCpyFrameNum+2));
- memcpy(pInfo->pComment, pExtContent+tmp, realCpyFrameNum);
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pComment = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
+ memset(pInfo->pComment, 0, (realCpyFrameNum + 2));
+ memcpy(pInfo->pComment, pExtContent + tmp, realCpyFrameNum);
pInfo->pComment[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->commentLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pComment, pExtContent, pInfo->commentLen);
- }
- else
- {
- pInfo->pComment = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->commentLen);
+ _STRNCPY_EX(pInfo->pComment, pExtContent, pInfo->commentLen);
+ } else {
+ pInfo->pComment = mmfile_string_convert((const char *)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->commentLen);
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
}
tmp = 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
+#endif
pInfo->tagV2Info.bDescriptionMarked = true;
- }
- else if(strncmp((char *)CompTmp, "SYLT", 4) == 0 && pInfo->tagV2Info.bSyncLyricsMarked == false)
- {
+ } else if (strncmp((char *)CompTmp, "SYLT", 4) == 0 && pInfo->tagV2Info.bSyncLyricsMarked == false) {
int idx = 0;
int copy_len = 0;
int copy_start_pos = tmp;
AvSynclyricsInfo *synclyrics_info = NULL;
GList *synclyrics_info_list = NULL;
-
- if(realCpyFrameNum > 5)
- {
+
+ if (realCpyFrameNum > 5) {
realCpyFrameNum -= 5;
tmp = 5;
- if(textEncodingType == AV_ID3V2_UTF16 || textEncodingType == AV_ID3V2_UTF16_BE)
- {
- while((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp))&& realCpyFrameNum > 4)
- {
+ if (textEncodingType == AV_ID3V2_UTF16 || textEncodingType == AV_ID3V2_UTF16_BE) {
+ while ((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp += 4;
}
- if((IS_ENCODEDBY_UTF16(pExtContent+tmp) || IS_ENCODEDBY_UTF16_R(pExtContent+tmp)) && realCpyFrameNum > 2)
- {
+ if ((IS_ENCODEDBY_UTF16(pExtContent + tmp) || IS_ENCODEDBY_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 2) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pSyncLyrics Never Get Here!!\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pSyncLyrics Never Get Here!!\n");
- #endif
- }
- }
- else if(textEncodingType == AV_ID3V2_UTF8)
- {
- while(pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else if (textEncodingType == AV_ID3V2_UTF8) {
+ while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_UTF8;
- }
- else
- {
- while(pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else {
+ while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_ISO_8859;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+#endif
- if(realCpyFrameNum < MMFILE_SYNC_LYRIC_INFO_MIN_LEN)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "failed to get Synchronised lyrics Info realCpyFramNum(%d)\n", realCpyFrameNum);
- #endif
+ if (realCpyFrameNum < MMFILE_SYNC_LYRIC_INFO_MIN_LEN) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("failed to get Synchronised lyrics Info realCpyFramNum(%d)\n", realCpyFrameNum);
+#endif
pInfo->syncLyricsNum = 0;
- }
- else
- {
- if(textEncodingType == AV_ID3V2_UTF16)
- {
- debug_warning ("[AV_ID3V2_UTF16] not implemented\n");
- }
- else if(textEncodingType == AV_ID3V2_UTF16_BE)
- {
- debug_warning ("[AV_ID3V2_UTF16_BE] not implemented\n");
- }
- else
- {
- for(idx = 0; idx < realCpyFrameNum; idx++)
- {
- if(pExtContent[tmp+idx] == 0x00)
- {
+ } else {
+ if (textEncodingType == AV_ID3V2_UTF16) {
+ debug_warning("[AV_ID3V2_UTF16] not implemented\n");
+ } else if (textEncodingType == AV_ID3V2_UTF16_BE) {
+ debug_warning("[AV_ID3V2_UTF16_BE] not implemented\n");
+ } else {
+ for (idx = 0; idx < realCpyFrameNum; idx++) {
+ if (pExtContent[tmp + idx] == 0x00) {
synclyrics_info = (AvSynclyricsInfo *)malloc(sizeof(AvSynclyricsInfo));
- if(textEncodingType == AV_ID3V2_UTF8) {
- synclyrics_info->lyric_info= mmfile_malloc(copy_len+1);
- memset(synclyrics_info->lyric_info, 0, copy_len+1);
- memcpy(synclyrics_info->lyric_info, pExtContent+copy_start_pos, copy_len);
- synclyrics_info->lyric_info[copy_len+1] = '\0';
- }
- else {
- synclyrics_info->lyric_info = mmfile_string_convert ((const char*)&pExtContent[copy_start_pos], copy_len, "UTF-8", charset_array[textEncodingType], NULL, NULL);
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ synclyrics_info->lyric_info = mmfile_malloc(copy_len + 1);
+ memset(synclyrics_info->lyric_info, 0, copy_len + 1);
+ memcpy(synclyrics_info->lyric_info, pExtContent + copy_start_pos, copy_len);
+ synclyrics_info->lyric_info[copy_len + 1] = '\0';
+ } else {
+ synclyrics_info->lyric_info = mmfile_string_convert((const char *)&pExtContent[copy_start_pos], copy_len, "UTF-8", charset_array[textEncodingType], NULL, NULL);
}
- synclyrics_info->time_info= (unsigned long)pExtContent[tmp+idx+1] << 24 | (unsigned long)pExtContent[tmp+idx+2] << 16 | (unsigned long)pExtContent[tmp+idx+3] << 8 | (unsigned long)pExtContent[tmp+idx+4];
+ synclyrics_info->time_info = (unsigned long)pExtContent[tmp + idx + 1] << 24 | (unsigned long)pExtContent[tmp + idx + 2] << 16 | (unsigned long)pExtContent[tmp + idx + 3] << 8 | (unsigned long)pExtContent[tmp + idx + 4];
idx += 4;
copy_start_pos = tmp + idx + 1;
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("[%d][%s] idx[%d], copy_len[%d] copy_start_pos[%d]", synclyrics_info->time_info, synclyrics_info->lyric_info, idx, copy_len, copy_start_pos);
- #endif
+#endif
copy_len = 0;
synclyrics_info_list = g_list_append(synclyrics_info_list, synclyrics_info);
}
- copy_len ++;
+ copy_len++;
}
pInfo->pSyncLyrics = synclyrics_info_list;
pInfo->syncLyricsNum = g_list_length(pInfo->pSyncLyrics);
}
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "SyncLyrics info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("SyncLyrics info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
}
tmp = 0;
pInfo->tagV2Info.bSyncLyricsMarked = true;
- }
- else if(strncmp((char *)CompTmp, "USLT", 4) == 0 && pInfo->tagV2Info.bUnsyncLyricsMarked == false)
- {
- if(realCpyFrameNum > 3)
- {
+ } else if (strncmp((char *)CompTmp, "USLT", 4) == 0 && pInfo->tagV2Info.bUnsyncLyricsMarked == false) {
+ if (realCpyFrameNum > 3) {
realCpyFrameNum -= 3;
tmp = 3;
- if(textEncodingType == AV_ID3V2_UTF16 || textEncodingType == AV_ID3V2_UTF16_BE)
- {
- while((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp))&& realCpyFrameNum > 4)
- {
+ if (textEncodingType == AV_ID3V2_UTF16 || textEncodingType == AV_ID3V2_UTF16_BE) {
+ while ((NEWLINE_OF_UTF16(pExtContent + tmp) || NEWLINE_OF_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 4) {
realCpyFrameNum -= 4;
tmp += 4;
}
- if((IS_ENCODEDBY_UTF16(pExtContent+tmp) || IS_ENCODEDBY_UTF16_R(pExtContent+tmp)) && realCpyFrameNum > 2)
- {
+ if ((IS_ENCODEDBY_UTF16(pExtContent + tmp) || IS_ENCODEDBY_UTF16_R(pExtContent + tmp)) && realCpyFrameNum > 2) {
realCpyFrameNum -= 2;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pUnsyncLyrics Never Get Here!!\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pUnsyncLyrics Never Get Here!!\n");
- #endif
- }
- }
- else if(textEncodingType == AV_ID3V2_UTF8)
- {
- while(pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else if (textEncodingType == AV_ID3V2_UTF8) {
+ while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_UTF8;
- }
- else
- {
- while(pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) // text string encoded by ISO-8859-1
- {
- realCpyFrameNum --;
+ } else {
+ while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
+ realCpyFrameNum--;
tmp++;
}
textEncodingType = AV_ID3V2_ISO_8859;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+#endif
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pUnsyncLyrics= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
- memset(pInfo->pUnsyncLyrics, 0, (realCpyFrameNum+2));
- memcpy(pInfo->pUnsyncLyrics, pExtContent+tmp, realCpyFrameNum);
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pUnsyncLyrics = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
+ memset(pInfo->pUnsyncLyrics, 0, (realCpyFrameNum + 2));
+ memcpy(pInfo->pUnsyncLyrics, pExtContent + tmp, realCpyFrameNum);
pInfo->pUnsyncLyrics[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->unsynclyricsLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pUnsyncLyrics, pExtContent, pInfo->unsynclyricsLen);
- }
- else
- {
- pInfo->pUnsyncLyrics = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->unsynclyricsLen);
+ _STRNCPY_EX(pInfo->pUnsyncLyrics, pExtContent, pInfo->unsynclyricsLen);
+ } else {
+ pInfo->pUnsyncLyrics = mmfile_string_convert((const char *)&pExtContent[tmp], realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->unsynclyricsLen);
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+#endif
}
tmp = 0;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
+#endif
pInfo->tagV2Info.bDescriptionMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TCON", 4) == 0 && pInfo->tagV2Info.bGenreMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pGenre= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TCON", 4) == 0 && pInfo->tagV2Info.bGenreMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pGenre = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pGenre, pExtContent, realCpyFrameNum);
pInfo->pGenre[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->genreLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pGenre, pExtContent, pInfo->genreLen);
- }
- else
- {
- pInfo->pGenre = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->genreLen);
+ _STRNCPY_EX(pInfo->pGenre, pExtContent, pInfo->genreLen);
+ } else {
+ pInfo->pGenre = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->genreLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
+#endif
- if((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
+ if ((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
bool ret = FALSE;
int int_genre = -1;
ret = is_numeric(pInfo->pGenre, pInfo->genreLen);
- if(ret == TRUE) {
- sscanf( pInfo->pGenre, "%d", &int_genre);
- #ifdef __MMFILE_TEST_MODE__
+ if (ret == TRUE) {
+ sscanf(pInfo->pGenre, "%d", &int_genre);
+#ifdef __MMFILE_TEST_MODE__
debug_msg("genre information is inteager [%d]\n", int_genre);
- #endif
+#endif
- //Change int to string
- if((0 <= int_genre) && (int_genre < GENRE_COUNT-1)) {
+ /*Change int to string */
+ if ((0 <= int_genre) && (int_genre < GENRE_COUNT - 1)) {
/*save genreinfo like "(123)". mm_file_id3tag_restore_content_info convert it to string*/
- char tmp_genre[6] = {0,}; /*ex. "(123)+NULL"*/
+ char tmp_genre[6] = {0, }; /*ex. "(123)+NULL"*/
int tmp_genre_len = 0;
- memset (tmp_genre, 0, 6);
+ memset(tmp_genre, 0, 6);
snprintf(tmp_genre, sizeof(tmp_genre), "(%d)", int_genre);
tmp_genre_len = strlen(tmp_genre);
- if(tmp_genre_len > 0) {
- if(pInfo->pGenre) _FREE_EX(pInfo->pGenre);
- pInfo->pGenre = mmfile_malloc (sizeof(char) * (tmp_genre_len + 1) );
- if (pInfo->pGenre)
- {
+ if (tmp_genre_len > 0) {
+ if (pInfo->pGenre) _FREE_EX(pInfo->pGenre);
+ pInfo->pGenre = mmfile_malloc(sizeof(char) * (tmp_genre_len + 1));
+ if (pInfo->pGenre) {
strncpy(pInfo->pGenre, tmp_genre, tmp_genre_len);
pInfo->pGenre[tmp_genre_len] = 0;
}
}
pInfo->tagV2Info.bGenreMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TRCK", 4) == 0 && pInfo->tagV2Info.bTrackNumMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pTrackNum= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TRCK", 4) == 0 && pInfo->tagV2Info.bTrackNumMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pTrackNum = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pTrackNum, pExtContent, realCpyFrameNum);
pInfo->pTrackNum[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->tracknumLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pTrackNum, pExtContent, pInfo->tracknumLen);
- }
- else
- {
- pInfo->pTrackNum = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->tracknumLen);
+ _STRNCPY_EX(pInfo->pTrackNum, pExtContent, pInfo->tracknumLen);
+ } else {
+ pInfo->pTrackNum = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->tracknumLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
+#endif
pInfo->tagV2Info.bTrackNumMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TENC", 4) == 0 && pInfo->tagV2Info.bEncByMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pEncBy= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TENC", 4) == 0 && pInfo->tagV2Info.bEncByMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pEncBy = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pEncBy, pExtContent, realCpyFrameNum);
pInfo->pEncBy[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->encbyLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pEncBy, pExtContent, pInfo->encbyLen);
- }
- else
- {
- pInfo->pEncBy = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->encbyLen);
+ _STRNCPY_EX(pInfo->pEncBy, pExtContent, pInfo->encbyLen);
+ } else {
+ pInfo->pEncBy = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->encbyLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
+#endif
pInfo->tagV2Info.bEncByMarked = true;
- }
- else if(strncmp((char *)CompTmp, "WXXX", 4) == 0 && pInfo->tagV2Info.bURLMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pURL= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "WXXX", 4) == 0 && pInfo->tagV2Info.bURLMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pURL = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pURL, pExtContent, realCpyFrameNum);
pInfo->pURL[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->urlLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pURL, pExtContent, pInfo->urlLen);
- }
- else
- {
- pInfo->pURL = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->urlLen);
+ _STRNCPY_EX(pInfo->pURL, pExtContent, pInfo->urlLen);
+ } else {
+ pInfo->pURL = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->urlLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
+#endif
pInfo->tagV2Info.bURLMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TCOP", 4) == 0 && pInfo->tagV2Info.bCopyRightMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pCopyright= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TCOP", 4) == 0 && pInfo->tagV2Info.bCopyRightMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pCopyright = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pCopyright, pExtContent, realCpyFrameNum);
pInfo->pCopyright[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->copyrightLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pCopyright, pExtContent, pInfo->copyrightLen);
- }
- else
- {
- pInfo->pCopyright = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->copyrightLen);
+ _STRNCPY_EX(pInfo->pCopyright, pExtContent, pInfo->copyrightLen);
+ } else {
+ pInfo->pCopyright = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->copyrightLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
+#endif
pInfo->tagV2Info.bCopyRightMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TOPE", 4) == 0 && pInfo->tagV2Info.bOriginArtistMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pOriginArtist= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TOPE", 4) == 0 && pInfo->tagV2Info.bOriginArtistMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pOriginArtist = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pOriginArtist, pExtContent, realCpyFrameNum);
pInfo->pOriginArtist[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->originartistLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pOriginArtist, pExtContent, pInfo->originartistLen);
- }
- else
- {
- pInfo->pOriginArtist = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->originartistLen);
+ _STRNCPY_EX(pInfo->pOriginArtist, pExtContent, pInfo->originartistLen);
+ } else {
+ pInfo->pOriginArtist = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->originartistLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
+#endif
pInfo->tagV2Info.bOriginArtistMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TCOM", 4) == 0 && pInfo->tagV2Info.bComposerMarked == false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pComposer= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TCOM", 4) == 0 && pInfo->tagV2Info.bComposerMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pComposer = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pComposer, pExtContent, realCpyFrameNum);
pInfo->pComposer[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->composerLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pComposer, pExtContent, pInfo->composerLen);
- }
- else
- {
- pInfo->pComposer = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->composerLen);
+ _STRNCPY_EX(pInfo->pComposer, pExtContent, pInfo->composerLen);
+ } else {
+ pInfo->pComposer = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->composerLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
+#endif
pInfo->tagV2Info.bComposerMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TDRC", 4) == 0 && pInfo->tagV2Info.bRecDateMarked== false) //TYER(year) and TRDA are replaced by the TDRC
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pRecDate= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TDRC", 4) == 0 && pInfo->tagV2Info.bRecDateMarked == false) { /*TYER(year) and TRDA are replaced by the TDRC */
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pRecDate = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pRecDate, pExtContent, realCpyFrameNum);
pInfo->pRecDate[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->recdateLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pRecDate, pExtContent, pInfo->recdateLen);
- }
- else
- {
- pInfo->pRecDate = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->recdateLen);
+ _STRNCPY_EX(pInfo->pRecDate, pExtContent, pInfo->recdateLen);
+ } else {
+ pInfo->pRecDate = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->recdateLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
+#endif
pInfo->tagV2Info.bRecDateMarked = true;
- }
- else if(strncmp((char *)CompTmp, "TIT1", 4) == 0 && pInfo->tagV2Info.bContentGroupMarked== false)
- {
- if(textEncodingType == AV_ID3V2_UTF8)
- {
- pInfo->pContentGroup= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ } else if (strncmp((char *)CompTmp, "TIT1", 4) == 0 && pInfo->tagV2Info.bContentGroupMarked == false) {
+ if (textEncodingType == AV_ID3V2_UTF8) {
+ pInfo->pContentGroup = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
memcpy(pInfo->pContentGroup, pExtContent, realCpyFrameNum);
pInfo->pContentGroup[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
pInfo->contentGroupLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pContentGroup, pExtContent, pInfo->contentGroupLen);
- }
- else
- {
- pInfo->pContentGroup = mmfile_string_convert ((const char*)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&pInfo->contentGroupLen);
+ _STRNCPY_EX(pInfo->pContentGroup, pExtContent, pInfo->contentGroupLen);
+ } else {
+ pInfo->pContentGroup = mmfile_string_convert((const char *)pExtContent, realCpyFrameNum, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&pInfo->contentGroupLen);
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pContentGroup returned = (%s), pInfo->contentGroupLen(%d)\n", pInfo->pContentGroup, pInfo->contentGroupLen);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pContentGroup returned = (%s), pInfo->contentGroupLen(%d)\n", pInfo->pContentGroup, pInfo->contentGroupLen);
+#endif
pInfo->tagV2Info.bContentGroupMarked = true;
- }
- else if(strncmp((char *)CompTmp, "APIC", 4) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000)
- {
- if(pExtContent[0] != '\0')
- {
- for(inx = 0; inx < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH-1; inx++)
- pInfo->imageInfo.imageMIMEType[inx] = '\0';//ini mimetype variable
-
- while((checkImgMimeTypeMax < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH-1) && pExtContent[checkImgMimeTypeMax] != '\0')
- {
+ } else if (strncmp((char *)CompTmp, "APIC", 4) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000) {
+ if (pExtContent[0] != '\0') {
+ for (inx = 0; inx < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH - 1; inx++)
+ pInfo->imageInfo.imageMIMEType[inx] = '\0';/*ini mimetype variable */
+
+ while ((checkImgMimeTypeMax < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH - 1) && pExtContent[checkImgMimeTypeMax] != '\0') {
pInfo->imageInfo.imageMIMEType[checkImgMimeTypeMax] = pExtContent[checkImgMimeTypeMax];
checkImgMimeTypeMax++;
}
pInfo->imageInfo.imgMimetypeLen = checkImgMimeTypeMax;
- }
- else
- {
+ } else {
pInfo->imageInfo.imgMimetypeLen = 0;
}
continue;
}
- if((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0))
- {
- imgstartOffset++;//endofMIME(1byte)
+ if ((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0)) {
+ imgstartOffset++;/*endofMIME(1byte) */
- if(pExtContent[imgstartOffset] < AV_ID3V2_PICTURE_TYPE_MAX)
- {
+ if (pExtContent[imgstartOffset] < AV_ID3V2_PICTURE_TYPE_MAX) {
pInfo->imageInfo.pictureType = pExtContent[imgstartOffset];
}
- imgstartOffset++;//PictureType(1byte)
+ imgstartOffset++;/*PictureType(1byte) */
- if(pExtContent[imgstartOffset] != 0x0)
- {
+ if (pExtContent[imgstartOffset] != 0x0) {
int cur_pos = 0;
int dis_len = 0;
int new_dis_len = 0;
char jpg_sign[3] = {0xff, 0xd8, 0xff};
- char png_sign[8] = {0x80, 0x50, 0x4e, 0x47,0x0d, 0x0a, 0x1a, 0x0a};
+ char png_sign[8] = {0x80, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a};
char *tmp_desc = NULL;
while (1) {
}
/*check end of image description*/
if ((pExtContent[imgstartOffset + cur_pos + 1] == jpg_sign[0]) ||
- (pExtContent[imgstartOffset + cur_pos + 1] == png_sign[0])) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "length of description (%d)", cur_pos);
- #endif
+ (pExtContent[imgstartOffset + cur_pos + 1] == png_sign[0])) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("length of description (%d)", cur_pos);
+#endif
break;
}
}
- cur_pos ++;
+ cur_pos++;
}
dis_len = cur_pos + 1;
tmp_desc = mmfile_malloc(sizeof(char) * dis_len);
- memcpy(tmp_desc, pExtContent + imgstartOffset, dis_len);
- debug_msg ( "tmp_desc %s\n", tmp_desc);
- /*convert description*/
- pInfo->imageInfo.imageDescription = mmfile_string_convert (tmp_desc, dis_len, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int*)&new_dis_len);
- debug_msg ( "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
- mmfile_free(tmp_desc);
+ if(tmp_desc != NULL) {
+ memcpy(tmp_desc, pExtContent + imgstartOffset, dis_len);
+ debug_msg("tmp_desc %s\n", tmp_desc);
+
+ /*convert description*/
+ pInfo->imageInfo.imageDescription = mmfile_string_convert(tmp_desc, dis_len, "UTF-8", charset_array[textEncodingType], NULL, (unsigned int *)&new_dis_len);
+ debug_msg("new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
+ mmfile_free(tmp_desc);
+
+ pInfo->imageInfo.imgDesLen = new_dis_len; /**/
+ }
- pInfo->imageInfo.imgDesLen = new_dis_len; /**/
imgstartOffset += cur_pos;
- }
- else
- {
- pInfo->imageInfo.imgDesLen= 0;
+ } else {
+ pInfo->imageInfo.imgDesLen = 0;
}
- if((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0))
- {
- imgstartOffset ++; // endofDesceriptionType(1byte)
+ if ((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0)) {
+ imgstartOffset++; /* endofDesceriptionType(1byte) */
- while(pExtContent[imgstartOffset] == '\0') //some content has useless '\0' in front of picture data
- {
- imgstartOffset ++;
+ while (pExtContent[imgstartOffset] == '\0') { /*some content has useless '\0' in front of picture data */
+ imgstartOffset++;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
+#endif
- if(realCpyFrameNum - imgstartOffset > 0)
- {
+ if (realCpyFrameNum - imgstartOffset > 0) {
pInfo->imageInfo.imageLen = realCpyFrameNum - imgstartOffset;
- pInfo->imageInfo.pImageBuf= mmfile_malloc (pInfo->imageInfo.imageLen+1);
+ pInfo->imageInfo.pImageBuf = mmfile_malloc(pInfo->imageInfo.imageLen + 1);
- if(pInfo->imageInfo.pImageBuf != NULL) {
- memcpy(pInfo->imageInfo.pImageBuf, pExtContent+ imgstartOffset, pInfo->imageInfo.imageLen);
+ if (pInfo->imageInfo.pImageBuf != NULL) {
+ memcpy(pInfo->imageInfo.pImageBuf, pExtContent + imgstartOffset, pInfo->imageInfo.imageLen);
pInfo->imageInfo.pImageBuf[pInfo->imageInfo.imageLen] = 0;
}
- if(IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
- pInfo->imageInfo.bURLInfo = true; //if mimetype is "-->", image date has an URL
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
- #endif
+ if (IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
+ pInfo->imageInfo.bURLInfo = true; /*if mimetype is "-->", image date has an URL */
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
+#endif
}
}
}
checkImgMimeTypeMax = 0;
inx = 0;
imgstartOffset = 0;
- pInfo->tagV2Info.bImageMarked= true;
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
- #endif
+ pInfo->tagV2Info.bImageMarked = true;
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
+#endif
}
}
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mmf_file_id3tag_parse_v224: All of the pExtContent Values are NULL\n");
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mmf_file_id3tag_parse_v224: All of the pExtContent Values are NULL\n");
+#endif
}
- }
- else
- {
+ } else {
curPos += purelyFramelen;
- if(purelyFramelen != 0)
+ if (purelyFramelen != 0)
needToloopv2taglen = MP3_TAGv2_23_TXT_HEADER_LEN;
}
- if(pExtContent) _FREE_EX(pExtContent);
+ if (pExtContent) _FREE_EX(pExtContent);
memset(CompTmp, 0, 4);
- if(curPos < taglen)
- {
+ if (curPos < taglen) {
needToloopv2taglen -= oneFrameLen;
v2numOfFrames++;
- }
- else
+ } else
needToloopv2taglen = MP3_TAGv2_23_TXT_HEADER_LEN;
oneFrameLen = 0;
release_characterset_array(charset_array);
- if(taglen)
+ if (taglen)
return true;
else
return false;
}
EXPORT_API
-void mm_file_id3tag_restore_content_info(AvFileContentInfo* pInfo)
+void mm_file_id3tag_restore_content_info(AvFileContentInfo *pInfo)
{
- char *mpegAudioGenre=NULL, *tmpGenreForV1Tag = NULL;
- bool bAdditionGenre= false /*, bMpegAudioFrame = false*/;
- int mpegAudioFileLen=0, idv2IntGenre=148, tmpinx=0/*, tmpinx2=0*/;
+ char *mpegAudioGenre = NULL/*, *tmpGenreForV1Tag = NULL*/;
+ bool bAdditionGenre = false /*, bMpegAudioFrame = false*/;
+ int mpegAudioFileLen = 0, idv2IntGenre = 148/*, tmpinx = 0, tmpinx2=0*/;
+#ifdef _SM_ONLY
char *pGenreForUTF16;
+#endif
+ unsigned char genre = pInfo->genre;
- // for Genre Info
- if(pInfo->tagV2Info.bGenreMarked == false)
- {
- if(pInfo->bV1tagFound == true)
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Genre: %d\n", pInfo->genre);
- #endif
- if(pInfo->genre > 147)
- {
- mpegAudioGenre = MpegAudio_Genre[148];
- }
- else
- {
- mpegAudioGenre = MpegAudio_Genre[pInfo->genre];
- }
-
- if(mpegAudioGenre!=NULL)
- {
- pInfo->genreLen = strlen(mpegAudioGenre);
- if (pInfo->genreLen > 0)
- {
- // Give space for NULL character. Hence added "+1"
- pInfo->pGenre = mmfile_malloc (sizeof(char) * (pInfo->genreLen + 1) );
- if (pInfo->pGenre)
- {
- strncpy(pInfo->pGenre, mpegAudioGenre, pInfo->genreLen);
+ /* for Genre Info */
+ if (pInfo->tagV2Info.bGenreMarked == false) {
+ if (pInfo->bV1tagFound == true) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Genre: %d\n", genre);
+#endif
+ if (genre > 147)
+ genre = 148;
+
+ if (MpegAudio_Genre[genre] != NULL) {
+ pInfo->genreLen = strlen(MpegAudio_Genre[genre]);
+ if (pInfo->genreLen > 0) {
+ /* Give space for NULL character. Hence added "+1" */
+ pInfo->pGenre = mmfile_malloc(sizeof(char) * (pInfo->genreLen + 1));
+ if (pInfo->pGenre) {
+ strncpy(pInfo->pGenre, MpegAudio_Genre[genre], pInfo->genreLen);
pInfo->pGenre[pInfo->genreLen] = '\0';
}
}
}
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Genre was not Found.\n");
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Genre was not Found.\n");
- #endif
- }
- }
- else if(pInfo->tagV2Info.bGenreMarked == true)
- {
- if(pInfo->genreLen && pInfo->tagV2Info.bGenreUTF16)
- {
- pInfo->pGenre[pInfo->genreLen+1] = '\0';
- mpegAudioGenre = mmfile_malloc (sizeof(char) * (pInfo->genreLen*AV_WM_LOCALCODE_SIZE_MAX + 1) );
- pGenreForUTF16 = (char *)pInfo->pGenre;
+ } else if (pInfo->tagV2Info.bGenreMarked == true) {
+ if (pInfo->genreLen && pInfo->tagV2Info.bGenreUTF16) {
+ pInfo->pGenre[pInfo->genreLen + 1] = '\0';
+ mpegAudioGenre = mmfile_malloc(sizeof(char) * (pInfo->genreLen * AV_WM_LOCALCODE_SIZE_MAX + 1));
#ifdef _SM_ONLY
- if(WmConvert2LCode(mpegAudioGenre, sizeof ( char ) * AV_WM_LOCALCODE_SIZE_MAX * ( pInfo->genreLen + 1 ), pGenreForUTF16))
- {
+ pGenreForUTF16 = (char *)pInfo->pGenre;
+
+ if (WmConvert2LCode(mpegAudioGenre, sizeof(char) * AV_WM_LOCALCODE_SIZE_MAX * (pInfo->genreLen + 1), pGenreForUTF16)) {
pInfo->genreLen = strlen(mpegAudioGenre);
mpegAudioGenre[pInfo->genreLen] = '\0';
}
#endif
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->genreLen size is Zero Or not UTF16 code! genreLen[%d] genre[%s]\n",pInfo->genreLen,pInfo->pGenre);
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->genreLen size is Zero Or not UTF16 code! genreLen[%d] genre[%s]\n", pInfo->genreLen, pInfo->pGenre);
+#endif
if (pInfo->pGenre) {
pInfo->genreLen = strlen(pInfo->pGenre);
- mpegAudioGenre = mmfile_malloc (sizeof(char) * (pInfo->genreLen + 1) );
- if(mpegAudioGenre != NULL) {
+ mpegAudioGenre = mmfile_malloc(sizeof(char) * (pInfo->genreLen + 1));
+ if (mpegAudioGenre != NULL) {
mpegAudioGenre[pInfo->genreLen] = '\0';
strncpy(mpegAudioGenre, pInfo->pGenre, pInfo->genreLen);
}
}
}
- if(pInfo->pGenre) _FREE_EX(pInfo->pGenre);
+ if (pInfo->pGenre) _FREE_EX(pInfo->pGenre);
- tmpinx = 0;
- if(mpegAudioGenre!=NULL)
- {
+ /*tmpinx = 0;*/
+ if (mpegAudioGenre != NULL) {
/**
*Genre number
* (XXX) XXX is 0 - 148
*/
- pInfo->genreLen = strlen (mpegAudioGenre);
+ pInfo->genreLen = strlen(mpegAudioGenre);
if (pInfo->genreLen >= 3 &&
- mpegAudioGenre[0] == '(' && mpegAudioGenre[pInfo->genreLen - 1] == ')') {
+ mpegAudioGenre[0] == '(' && mpegAudioGenre[pInfo->genreLen - 1] == ')') {
bAdditionGenre = true;
for (mpegAudioFileLen = 1; mpegAudioFileLen <= pInfo->genreLen - 2; mpegAudioFileLen++) {
- if(mpegAudioGenre[mpegAudioFileLen] < '0' || mpegAudioGenre[mpegAudioFileLen] > '9') {
+ if (mpegAudioGenre[mpegAudioFileLen] < '0' || mpegAudioGenre[mpegAudioFileLen] > '9') {
bAdditionGenre = false;
break;
}
}
}
- if(bAdditionGenre == true)
- {
- idv2IntGenre = atoi(mpegAudioGenre+1);
- if(idv2IntGenre > 147 || idv2IntGenre < 0)
- {
- tmpGenreForV1Tag = MpegAudio_Genre[148];
- }
- else
- {
- tmpGenreForV1Tag = MpegAudio_Genre[idv2IntGenre];
- }
- if(tmpGenreForV1Tag!=NULL)
- {
- pInfo->genreLen = strlen(tmpGenreForV1Tag);
- if (pInfo->genreLen > 0)
- {
- // Give space for NULL character. Hence added "+1"
- pInfo->pGenre = mmfile_malloc (sizeof(char) * (pInfo->genreLen + 1) );
- if (pInfo->pGenre)
- {
- strncpy(pInfo->pGenre, tmpGenreForV1Tag, pInfo->genreLen);
+ if (bAdditionGenre == true) {
+ idv2IntGenre = atoi(mpegAudioGenre + 1);
+
+ if (idv2IntGenre > 147 || idv2IntGenre < 0)
+ idv2IntGenre = 148;
+
+ if (MpegAudio_Genre[idv2IntGenre] != NULL) {
+ pInfo->genreLen = strlen(MpegAudio_Genre[idv2IntGenre]);
+ if (pInfo->genreLen > 0) {
+ /* Give space for NULL character. Hence added "+1" */
+ pInfo->pGenre = mmfile_malloc(sizeof(char) * (pInfo->genreLen + 1));
+ if (pInfo->pGenre) {
+ strncpy(pInfo->pGenre, MpegAudio_Genre[idv2IntGenre], pInfo->genreLen);
pInfo->pGenre[pInfo->genreLen] = 0;
}
}
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pGenre = %s\n", pInfo->pGenre);
- #endif
- }
- else if (bAdditionGenre == false && pInfo->genreLen > 0)
- {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pGenre = %s\n", pInfo->pGenre);
+#endif
+ } else if (bAdditionGenre == false && pInfo->genreLen > 0) {
/**
* Genre string.
*/
-
- // Give space for NULL character. Hence added "+1"
- pInfo->pGenre = mmfile_malloc (sizeof(char) * (pInfo->genreLen + 1) );
- if (pInfo->pGenre)
- {
+
+ /* Give space for NULL character. Hence added "+1" */
+ pInfo->pGenre = mmfile_malloc(sizeof(char) * (pInfo->genreLen + 1));
+ if (pInfo->pGenre) {
strncpy(pInfo->pGenre, mpegAudioGenre, pInfo->genreLen);
pInfo->pGenre[pInfo->genreLen] = '\0';
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pGenre = %s, pInfo->genreLen = %d\n", pInfo->pGenre, pInfo->genreLen);
- #endif
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Failed to \"(...)\" value to genre = %s\n", pInfo->pGenre);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("pInfo->pGenre = %s, pInfo->genreLen = %d\n", pInfo->pGenre, pInfo->genreLen);
+#endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Failed to \"(...)\" value to genre = %s\n", pInfo->pGenre);
+#endif
}
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("mpegAudioGenre = %x\n", mpegAudioGenre);
+#endif
}
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "mpegAudioGenre = %x\n", mpegAudioGenre);
- #endif
- }
- if(mpegAudioGenre)
+ if (mpegAudioGenre)
_FREE_EX(mpegAudioGenre);
- }
- else
- {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Neither ID3 v1 nor v2 info doesn't have Genre Info.\n");
- #endif
+ } else {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Neither ID3 v1 nor v2 info doesn't have Genre Info.\n");
+#endif
}
}
-void mm_file_free_synclyrics_list(GList * synclyrics_list)
+void mm_file_free_synclyrics_list(GList *synclyrics_list)
{
int list_len = 0;
int idx = 0;
free(synclyrics_info->lyric_info);
synclyrics_info->lyric_info = NULL;
-
+
free(synclyrics_info);
synclyrics_info = NULL;
}
g_list_free(synclyrics_list);
synclyrics_list = NULL;
}
-
+
return;
}
/***********************************************************************/
/* Internal functions */
/***********************************************************************/
-static int _MMFileSearchID3Tag (MMFileIOHandle *fp, unsigned int *offset);
-static int _MMFileIsMP3Header (void *header);
-static int _MMFileIsOGGHeader (void *header);
-static int _MMFileIsREALHeader (void *header);
-static int _MMFileIsMP4Header (void *header);
-static int _MMFileIsWAVHeader (void *header);
-static int _MMFileIsAVIHeader (void *header);
-static int _MMFileIsMIDHeader (void *header);
-static int _MMFileIsMMFHeader (void *header);
-static int _MMFileIsIMYHeader (void *header);
-static int _MMFileIsASFHeader (void *header);
-static int _MMFileIsAMRHeader (void *header);
-static int _MMFileIsFLACHeader (void *header);
-static int _MMFileIsFLVHeader (void *header);
-static int _MMFileIsMPEGTSHeader (MMFileIOHandle *fp);
-static int _MMFileIsMPEGPSHeader (void *header);
-static int _MMFileIsMPEGAUDIOHeader (void *header);
-static int _MMFileIsMPEGVIDEOHeader (void *header);
+static int _MMFileSearchID3Tag(MMFileIOHandle *fp, unsigned int *offset);
+static int _MMFileIsMP3Header(void *header);
+static int _MMFileIsOGGHeader(void *header);
+static int _MMFileIsREALHeader(void *header);
+static int _MMFileIsMP4Header(void *header);
+static int _MMFileIsWAVHeader(void *header);
+static int _MMFileIsAVIHeader(void *header);
+static int _MMFileIsMIDHeader(void *header);
+static int _MMFileIsMMFHeader(void *header);
+static int _MMFileIsIMYHeader(void *header);
+static int _MMFileIsASFHeader(void *header);
+static int _MMFileIsAMRHeader(void *header);
+static int _MMFileIsFLACHeader(void *header);
+static int _MMFileIsFLVHeader(void *header);
+static int _MMFileIsMPEGTSHeader(MMFileIOHandle *fp);
+static int _MMFileIsMPEGPSHeader(void *header);
+static int _MMFileIsMPEGAUDIOHeader(void *header);
+static int _MMFileIsMPEGVIDEOHeader(void *header);
/***********************************************************************/
/* MP3 Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMP3 (MMFileIOHandle *pFileIO, const char *mmfileuri, int frameCnt)
+int MMFileFormatIsValidMP3(MMFileIOHandle *pFileIO, const char *mmfileuri, int frameCnt)
{
#define _MMFILE_MP3_HEADER_LENGTH 4
#define _MMFILE_MP3_BUFFER_LENGTH 8200
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MP3_BUFFER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MP3_BUFFER_LENGTH] = {0, };
long long filesize = 0;
- unsigned int sizeID3 = 0;
- int readed = 0;
- unsigned int startoffset = 0;
- unsigned int endoffset = 0;
- unsigned int i = 0, j = 0;
- int ret = 0,frameSize,count,offset;
-
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
- if(ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ unsigned int sizeID3 = 0;
+ unsigned int readed = 0;
+ unsigned int startoffset = 0;
+ unsigned int endoffset = 0;
+ unsigned int frameSize = 0;
+ unsigned int i = 0, j = 0;
+ int ret = 0, count, offset;
+
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
+ if (ret == MMFILE_IO_FAILED) {
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- mmfile_seek (fp, 0L, MMFILE_SEEK_END);
- filesize = mmfile_tell (fp);
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_END);
+ filesize = mmfile_tell(fp);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (filesize < _MMFILE_MP3_HEADER_LENGTH) {
- debug_error ( "header is too small.\n");
+ debug_error("header is too small.\n");
ret = 0;
goto exit;
}
/* Search the existance of ID3 tag */
- ret = _MMFileSearchID3Tag (fp, &sizeID3);
+ ret = _MMFileSearchID3Tag(fp, &sizeID3);
if (ret == 0) {
debug_error("Error in searching the ID3 tag\n");
-// goto exit;
+ /* goto exit; */
}
ret = 0;
/* set begin and end point at the file */
startoffset += sizeID3;
endoffset = startoffset + 102400;
- if(endoffset > filesize - _MMFILE_MP3_HEADER_LENGTH)
+ if (endoffset > filesize - _MMFILE_MP3_HEADER_LENGTH)
endoffset = filesize - _MMFILE_MP3_HEADER_LENGTH;
-
+
/* find sync bit */
i = startoffset;
count = 0;
-
+
while (i < endoffset) {
- mmfile_seek (fp, i, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MP3_BUFFER_LENGTH);
+ mmfile_seek(fp, i, MMFILE_SEEK_SET);
+ readed = mmfile_read(fp, buffer, _MMFILE_MP3_BUFFER_LENGTH);
if (readed < _MMFILE_MP3_HEADER_LENGTH) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
break;
}
offset = 1;
for (j = 0; (j <= readed - _MMFILE_MP3_HEADER_LENGTH); j = j + offset) {
- frameSize = _MMFileIsMP3Header (buffer+j);
+ frameSize = _MMFileIsMP3Header(buffer + j);
offset = 1;
-
+
if (frameSize) {
-
- if((j+frameSize) >= (endoffset-(i+_MMFILE_MP3_HEADER_LENGTH))) {
+
+ if ((j + frameSize) >= (endoffset - (i + _MMFILE_MP3_HEADER_LENGTH))) {
goto failMP3;
}
- if((j+frameSize) >= (readed - _MMFILE_MP3_HEADER_LENGTH)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "MP3 coner hit %d %d\n", j, frameSize);
- #endif
+ if ((j + frameSize) >= (readed - _MMFILE_MP3_HEADER_LENGTH)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MP3 coner hit %d %d\n", j, frameSize);
+#endif
break;
}
- frameSize = _MMFileIsMP3Header (buffer+j+frameSize);
+ frameSize = _MMFileIsMP3Header(buffer + j + frameSize);
- if(frameSize) {
+ if (frameSize) {
offset = frameSize;
count++;
- if(count == frameCnt) {
+ if (count == frameCnt) {
ret = 1;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected at %d\n", i+j);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected at %d\n", i + j);
+#endif
goto exit;
}
} else {
}
/*If j is zero, this loop is infinite */
- if (j ==0) j++;
+ if (j == 0) j++;
i = i + j;
}
failMP3:
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Not Detected at: %d\n",i+j);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Not Detected at: %d\n", i + j);
+#endif
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* AAC Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidAAC (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidAAC(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_AAC_HEADER_LENGTH 4
#define _MMFILE_AAC_BUFFER_LENGTH 8200
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_AAC_BUFFER_LENGTH] = {0,};
- unsigned int sizeID3 = 0;
- long long filesize = 0;
- int readed = 0;
- unsigned int startoffset = 0;
- unsigned int endoffset = 0;
- unsigned int i = 0, j = 0;
+ unsigned char buffer[_MMFILE_AAC_BUFFER_LENGTH] = {0, };
+ unsigned int sizeID3 = 0;
+ long long filesize = 0;
+ unsigned int readed = 0;
+ unsigned int startoffset = 0;
+ unsigned int endoffset = 0;
+ unsigned int i = 0, j = 0;
int ret = 0;
- unsigned int sync,frameSize;
+ unsigned int sync, frameSize;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
/* Initialize the members of handle */
- mmfile_seek (fp, 0, MMFILE_SEEK_END);
+ mmfile_seek(fp, 0, MMFILE_SEEK_END);
filesize = mmfile_tell(fp);
- mmfile_seek (fp, 0, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_AAC_HEADER_LENGTH) {
- debug_error ( "header is too small.\n");
+ debug_error("header is too small.\n");
ret = 0;
goto exit;
}
/* Search the existance of ID3 tag */
- ret = _MMFileSearchID3Tag (fp, &sizeID3);
+ ret = _MMFileSearchID3Tag(fp, &sizeID3);
if (ret == 0) {
debug_error("Error in searching the ID3 tag\n");
-// goto exit;
+ /* goto exit; */
}
ret = 0;
/* set begin and end point at the file */
startoffset += sizeID3;
endoffset = startoffset + 10240;
- if(endoffset > filesize - _MMFILE_AAC_HEADER_LENGTH)
+ if (endoffset > filesize - _MMFILE_AAC_HEADER_LENGTH)
endoffset = filesize - _MMFILE_AAC_HEADER_LENGTH;
-
+
i = startoffset;
while (i < endoffset) {
- mmfile_seek (fp, i, MMFILE_SEEK_SET);
+ mmfile_seek(fp, i, MMFILE_SEEK_SET);
+
+ readed = mmfile_read(fp, buffer, _MMFILE_AAC_BUFFER_LENGTH);
- readed = mmfile_read (fp, buffer, _MMFILE_AAC_BUFFER_LENGTH);
-
if (readed < _MMFILE_AAC_HEADER_LENGTH) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
break;
}
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "read error. size = %d. i = %d\n", readed,i);
- #endif
- for(j=0; (j < readed - _MMFILE_AAC_HEADER_LENGTH); j++) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("read error. size = %d. i = %d\n", readed, i);
+#endif
+ for (j = 0; (j < readed - _MMFILE_AAC_HEADER_LENGTH); j++) {
- sync = ((buffer[j]<<8)|(buffer[j+1]));
+ sync = ((buffer[j] << 8) | (buffer[j + 1]));
- if ( (sync & 0xFFF6) == 0xFFF0) {
- frameSize = (((buffer[j+3]&0x03)<<11) | (buffer[j+4]<<3) | ((buffer[j+5]&0xE0)>>5));
+ if ((sync & 0xFFF6) == 0xFFF0) {
+ frameSize = (((buffer[j + 3] & 0x03) << 11) | (buffer[j + 4] << 3) | ((buffer[j + 5] & 0xE0) >> 5));
- if(frameSize == 0 ) {
- continue;
+ if (frameSize == 0) {
+ continue;
}
- if((j+frameSize) >= (endoffset-(i+2))) {
+ if ((j + frameSize) >= (endoffset - (i + 2))) {
goto fail;
}
- if((j+frameSize) >= (readed - 2)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "AAC coner hit %d %d\n", j, frameSize);
- #endif
+ if ((j + frameSize) >= (readed - 2)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("AAC coner hit %d %d\n", j, frameSize);
+#endif
break;
}
- sync = ( (buffer[j+frameSize]<<8) | (buffer[j+frameSize+1]));
+ sync = ((buffer[j + frameSize] << 8) | (buffer[j + frameSize + 1]));
if ((sync & 0xFFF6) == 0xFFF0) {
ret = 1;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "AAC ADTS Header Detected at %d\n", i+j);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("AAC ADTS Header Detected at %d\n", i + j);
+#endif
goto exit;
}
- } else if (!memcmp((buffer+j),"ADIF",4)) {
+ } else if (!memcmp((buffer + j), "ADIF", 4)) {
ret = 1;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "AAC ADIF Header Detected at %d\n", i+j);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("AAC ADIF Header Detected at %d\n", i + j);
+#endif
goto exit;
}
}
/*If j is zero, this loop is infinite */
- if (j ==0) j++;
+ if (j == 0) j++;
i = i + j;
}
fail:
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected Failed\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected Failed\n");
+#endif
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* OGG Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidOGG (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidOGG(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_OGG_HEADER_LENGTH 4
#define _MMFILE_OGG_BUFFER_LENGTH 512
#define _MMFILE_OGG_CHECK_LIMIT (_MMFILE_OGG_HEADER_LENGTH * 1000)
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_OGG_BUFFER_LENGTH] = {0,};
- unsigned int sizeID3 = 0;
- long long filesize = 0;
- int readed = 0;
- unsigned int startoffset = 0;
- unsigned int endoffset = 0;
- unsigned int i = 0, j = 0;
+ unsigned char buffer[_MMFILE_OGG_BUFFER_LENGTH] = {0, };
+ unsigned int sizeID3 = 0;
+ long long filesize = 0;
+ unsigned int readed = 0;
+ unsigned int startoffset = 0;
+ unsigned int endoffset = 0;
+ unsigned int i = 0, j = 0;
int ret = 0;
unsigned int check_limit = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
ret = 0;
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
/* Initialize the members of handle */
- mmfile_seek (fp, 0, MMFILE_SEEK_END);
+ mmfile_seek(fp, 0, MMFILE_SEEK_END);
filesize = mmfile_tell(fp);
- mmfile_seek (fp, 0, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_OGG_HEADER_LENGTH) {
- debug_error ( "header is too small.\n");
+ debug_error("header is too small.\n");
ret = 0;
goto exit;
}
/* Search the existance of ID3 tag */
- ret = _MMFileSearchID3Tag (fp, &sizeID3);
- if(ret == 0) {
+ ret = _MMFileSearchID3Tag(fp, &sizeID3);
+ if (ret == 0) {
debug_error("Error in searching the ID3 tag\n");
-// goto exit;
+ /* goto exit; */
}
ret = 0;
i = startoffset;
while (i <= check_limit) {
- mmfile_seek (fp, i, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_OGG_BUFFER_LENGTH);
+ mmfile_seek(fp, i, MMFILE_SEEK_SET);
+ readed = mmfile_read(fp, buffer, _MMFILE_OGG_BUFFER_LENGTH);
if (readed < _MMFILE_OGG_HEADER_LENGTH) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
break;
}
for (j = 0; (j <= readed - _MMFILE_OGG_HEADER_LENGTH); j++) {
- if (1 == _MMFileIsOGGHeader (buffer+j)) {
+ if (1 == _MMFileIsOGGHeader(buffer + j)) {
ret = 1;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected at %d\n", i+j);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected at %d\n", i + j);
+#endif
goto exit;
}
}
- memset (buffer, 0x00, _MMFILE_OGG_BUFFER_LENGTH);
+ memset(buffer, 0x00, _MMFILE_OGG_BUFFER_LENGTH);
i = i + j;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MIDI Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMID (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMID(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_MIDI_HEADER_LENGTH 4
#define _MMFILE_MIDI_BUFFER_LENGTH 512
#define _MMFILE_MIDI_CHECK_LIMIT (_MMFILE_MIDI_HEADER_LENGTH * 1024)
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MIDI_BUFFER_LENGTH] = {0,};
- long long filesize = 0;
- int readed = 0;
- unsigned int startoffset = 0;
- unsigned int endoffset = 0;
- unsigned int i = 0, j = 0;
+ unsigned char buffer[_MMFILE_MIDI_BUFFER_LENGTH] = {0, };
+ long long filesize = 0;
+ unsigned int readed = 0;
+ unsigned int startoffset = 0;
+ unsigned int endoffset = 0;
+ unsigned int i = 0, j = 0;
int ret = 0;
unsigned int check_limit = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
/* Initialize the members of handle */
- mmfile_seek (fp, 0, MMFILE_SEEK_END);
+ mmfile_seek(fp, 0, MMFILE_SEEK_END);
filesize = mmfile_tell(fp);
- mmfile_seek (fp, 0, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_MIDI_HEADER_LENGTH) {
- debug_error ( "header is too small.\n");
+ debug_error("header is too small.\n");
ret = 0;
goto exit;
}
i = startoffset;
while (i <= check_limit) {
- mmfile_seek (fp, i, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MIDI_BUFFER_LENGTH);
+ mmfile_seek(fp, i, MMFILE_SEEK_SET);
+ readed = mmfile_read(fp, buffer, _MMFILE_MIDI_BUFFER_LENGTH);
if (readed < _MMFILE_MIDI_HEADER_LENGTH) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
break;
}
for (j = 0; (j <= readed - _MMFILE_MIDI_HEADER_LENGTH); j++) {
- if (1 == _MMFileIsMIDHeader (buffer+j)) {
+ if (1 == _MMFileIsMIDHeader(buffer + j)) {
ret = 1;
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected at %d\n", i+j);
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected at %d\n", i + j);
+#endif
goto exit;
}
}
- memset (buffer, 0x00, _MMFILE_MIDI_BUFFER_LENGTH);
+ memset(buffer, 0x00, _MMFILE_MIDI_BUFFER_LENGTH);
i = i + j;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* WAV Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidWAV (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidWAV(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_WAV_HEADER_LENGTH 15
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_WAV_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_WAV_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_WAV_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_WAV_HEADER_LENGTH);
if (_MMFILE_WAV_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsWAVHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsWAVHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MP4 Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMP4 (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMP4(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_MP4_HEADER_LENGTH 4
#define _MMFILE_MP4_CHECK_LIMIT (1024*10) /*10Kbyte*/
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MP4_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MP4_HEADER_LENGTH] = {0, };
long long filesize = 0;
int readed = 0;
unsigned int startoffset = 0;
int ret = 0;
unsigned int check_limit = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
/* Initialize the members of handle */
- mmfile_seek (fp, 0, MMFILE_SEEK_END);
+ mmfile_seek(fp, 0, MMFILE_SEEK_END);
filesize = mmfile_tell(fp);
- mmfile_seek (fp, 0, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_MP4_HEADER_LENGTH) {
- debug_error ( "header is too small.\n");
+ debug_error("header is too small.\n");
ret = 0;
goto exit;
}
ret = 0;
/**@note weak check*/
- check_limit = (filesize > _MMFILE_MP4_CHECK_LIMIT) ? _MMFILE_MP4_CHECK_LIMIT: filesize;
+ check_limit = (filesize > _MMFILE_MP4_CHECK_LIMIT) ? _MMFILE_MP4_CHECK_LIMIT : filesize;
for (startoffset = 0; check_limit - (startoffset + _MMFILE_MP4_HEADER_LENGTH) > 0; startoffset++) {
- mmfile_seek (fp, startoffset, MMFILE_SEEK_SET);
+ mmfile_seek(fp, startoffset, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MP4_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_MP4_HEADER_LENGTH);
if (readed != _MMFILE_MP4_HEADER_LENGTH) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
/*input is 4byte*/
- if (1 == _MMFileIsMP4Header (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("MP4 Header Detected\n");
- #endif
+ if (1 == _MMFileIsMP4Header(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("MP4 Header Detected\n");
+#endif
ret = 1;
goto exit;
}
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* AVI Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidAVI (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidAVI(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_AVI_HEADER_LENGTH 12
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_AVI_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_AVI_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_AVI_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_AVI_HEADER_LENGTH);
if (_MMFILE_AVI_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsAVIHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected \n");
- #endif
+ if (1 == _MMFileIsAVIHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected \n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* ASF Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidASF (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidASF(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_ASF_HEADER_LENGTH 16
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_ASF_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_ASF_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_ASF_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_ASF_HEADER_LENGTH);
if (_MMFILE_ASF_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsASFHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsASFHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* WMA Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidWMA (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidWMA(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_ASF_HEADER_LENGTH 16
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_ASF_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_ASF_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_ASF_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_ASF_HEADER_LENGTH);
if (_MMFILE_ASF_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsASFHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsASFHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* WMV Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidWMV (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidWMV(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
- #define _MMFILE_ASF_HEADER_LENGTH 16
+#define _MMFILE_ASF_HEADER_LENGTH 16
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_ASF_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_ASF_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_ASF_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_ASF_HEADER_LENGTH);
if (_MMFILE_ASF_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsASFHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsASFHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MMF Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMMF (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMMF(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_MMF_HEADER_LENGTH 18
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MMF_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MMF_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MMF_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_MMF_HEADER_LENGTH);
if (_MMFILE_MMF_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsMMFHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsMMFHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MMF Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidIMY (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidIMY(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_IMY_HEADER_LENGTH 13
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_IMY_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_IMY_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_IMY_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_IMY_HEADER_LENGTH);
if (_MMFILE_IMY_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsIMYHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsIMYHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* AMR Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidAMR (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidAMR(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_AMR_MAX_HEADER_SIZE 15
#define _MMFILE_AMR_MIN_HEADER_SIZE 6
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_AMR_MAX_HEADER_SIZE] = {0,};
+ unsigned char buffer[_MMFILE_AMR_MAX_HEADER_SIZE] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_AMR_MAX_HEADER_SIZE);
+ readed = mmfile_read(fp, buffer, _MMFILE_AMR_MAX_HEADER_SIZE);
if (_MMFILE_AMR_MAX_HEADER_SIZE != readed) {
- debug_error ("read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsAMRHeader (buffer)) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
- #endif
+ if (1 == _MMFileIsAMRHeader(buffer)) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("Header Detected\n");
+#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* Matroska Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMatroska (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMatroska(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_EBML_MARKER_LENGTH 4
#define _MMFILE_MKV_READ_BUFFER_LENGTH 2048
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MKV_READ_BUFFER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MKV_READ_BUFFER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- int len_mask = 0x80, size = 1, n = 1, total = 0;
+ int len_mask = 0x80;
+ unsigned int size = 1, n = 1, total = 0;
char probe_data[] = { 'm', 'a', 't', 'r', 'o', 's', 'k', 'a' };
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MKV_READ_BUFFER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_MKV_READ_BUFFER_LENGTH);
if (_MMFILE_MKV_READ_BUFFER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
/* ebml header? */
if (buffer[0] != 0x1A || buffer[1] != 0x45 || buffer[2] != 0xDF || buffer[3] != 0xA3) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("This is not a EBML format\n");
+ debug_msg("This is not a EBML format\n");
#endif
ret = 0;
goto exit;
/* length of header */
total = buffer[4];
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("Initial total header size = [0x%x]\n", total);
+ debug_msg("Initial total header size = [0x%x]\n", total);
#endif
while (size <= 8 && !(total & len_mask)) {
- debug_error ("This case can not be handled yet....");
+ debug_error("This case can not be handled yet....");
size++;
len_mask >>= 1;
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("Final total header size = [%d]\n", total);
+ debug_msg("Final total header size = [%d]\n", total);
#endif
if (size > 8) {
- debug_error ("This case can not be handled yet....");
+ debug_error("This case can not be handled yet....");
ret = 0;
goto exit;
}
while (n < size) {
total = (total << 8) | buffer[4 + n++];
- debug_error ("This case can not be handled yet....");
+ debug_error("This case can not be handled yet....");
}
/* Does the probe data contain the whole header? */
if (_MMFILE_MKV_READ_BUFFER_LENGTH < 4 + size + total)
return 0;
- for (n = 4+size ; n <= 4+size+total - sizeof (probe_data); n++) {
- if (!memcmp (&buffer[n], probe_data, sizeof (probe_data))) {
+ for (n = 4 + size ; n <= 4 + size + total - sizeof(probe_data); n++) {
+ if (!memcmp(&buffer[n], probe_data, sizeof(probe_data))) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ("String matroska found!!!\n");
+ debug_msg("String matroska found!!!\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* QT Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidQT (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidQT(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
return 1;
}
/* Flac Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidFLAC (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidFLAC(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_FLAC_HEADER_LENGTH 5 /*fLaC*/
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_FLAC_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_FLAC_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_FLAC_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_FLAC_HEADER_LENGTH);
if (_MMFILE_FLAC_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsFLACHeader (buffer)) {
+ if (1 == _MMFileIsFLACHeader(buffer)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* FLV(flash video) Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidFLV (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidFLV(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_FLV_HEADER_LENGTH 4 /*FLV*/
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_FLV_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_FLV_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_FLV_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_FLV_HEADER_LENGTH);
if (_MMFILE_FLV_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsFLVHeader (buffer)) {
+ if (1 == _MMFileIsFLVHeader(buffer)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* REAL Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidREAL (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidREAL(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_RMVB_HEADER_LENGTH 4 /*RMF*/
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_RMVB_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_RMVB_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_RMVB_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_RMVB_HEADER_LENGTH);
if (_MMFILE_RMVB_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsREALHeader (buffer)) {
+ if (1 == _MMFileIsREALHeader(buffer)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
#define TS_MAX_PACKET_SIZE 204
EXPORT_API
-int MMFileFormatIsValidMPEGTS (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMPEGTS(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[TS_MAX_PACKET_SIZE] = {0,};
+ unsigned char buffer[TS_MAX_PACKET_SIZE] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, TS_MAX_PACKET_SIZE);
+ readed = mmfile_read(fp, buffer, TS_MAX_PACKET_SIZE);
if (TS_MAX_PACKET_SIZE != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (_MMFileIsMPEGTSHeader(fp) != MPEGTS_NONE) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MPEG-PS Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMPEGPS (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMPEGPS(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_MPEGPS_HEADER_LENGTH 4
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MPEGPS_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MPEGPS_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MPEGPS_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_MPEGPS_HEADER_LENGTH);
if (_MMFILE_MPEGPS_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsMPEGPSHeader (buffer)) {
+ if (1 == _MMFileIsMPEGPSHeader(buffer)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MPEG AUDIO Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMPEGAUDIO (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMPEGAUDIO(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_MPEGAUDIO_HEADER_LENGTH 4
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MPEGAUDIO_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MPEGAUDIO_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MPEGAUDIO_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_MPEGAUDIO_HEADER_LENGTH);
if (_MMFILE_MPEGAUDIO_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsMPEGAUDIOHeader (buffer)) {
+ if (1 == _MMFileIsMPEGAUDIOHeader(buffer)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/* MPEG VIDEO Header Check API */
/***********************************************************************/
EXPORT_API
-int MMFileFormatIsValidMPEGVIDEO (MMFileIOHandle *pFileIO, const char *mmfileuri)
+int MMFileFormatIsValidMPEGVIDEO(MMFileIOHandle *pFileIO, const char *mmfileuri)
{
#define _MMFILE_MPEGVIDEO_HEADER_LENGTH 4
MMFileIOHandle *fp = pFileIO;
- unsigned char buffer[_MMFILE_MPEGVIDEO_HEADER_LENGTH] = {0,};
+ unsigned char buffer[_MMFILE_MPEGVIDEO_HEADER_LENGTH] = {0, };
int readed = 0;
int ret = 0;
- if(fp == NULL) {
- ret = mmfile_open (&fp, mmfileuri, MMFILE_RDONLY);
+ if (fp == NULL) {
+ ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error ("error: mmfile_open\n");
+ debug_error("error: mmfile_open\n");
goto exit;
}
}
- mmfile_seek (fp, 0L, MMFILE_SEEK_SET);
+ mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
- readed = mmfile_read (fp, buffer, _MMFILE_MPEGVIDEO_HEADER_LENGTH);
+ readed = mmfile_read(fp, buffer, _MMFILE_MPEGVIDEO_HEADER_LENGTH);
if (_MMFILE_MPEGVIDEO_HEADER_LENGTH != readed) {
- debug_error ( "read error. size = %d. Maybe end of file.\n", readed);
+ debug_error("read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
- if (1 == _MMFileIsMPEGVIDEOHeader (buffer)) {
+ if (1 == _MMFileIsMPEGVIDEOHeader(buffer)) {
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "Header Detected\n");
+ debug_msg("Header Detected\n");
#endif
ret = 1;
goto exit;
}
exit:
- if(pFileIO == NULL && fp != NULL)
+ if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
return ret;
/***********************************************************************/
/* Implementation of Internal Functions */
/***********************************************************************/
-static int _MMFileIsASFHeader (void *header)
+static int _MMFileIsASFHeader(void *header)
{
- /* ID: 30 26 B2 75 8E 66 CF 11 A6 D9 00 AA 00 62 CE 6C */
+ /* ID: 30 26 B2 75 8E 66 CF 11 A6 D9 00 AA 00 62 CE 6C */
unsigned char *s = header;
- if ( (*(s + 0) == 0x30) &&
- (*(s + 1) == 0x26) &&
- (*(s + 2) == 0xB2) &&
- (*(s + 3) == 0x75) &&
- (*(s + 4) == 0x8E) &&
- (*(s + 5) == 0x66) &&
- (*(s + 6) == 0xCF) &&
- (*(s + 7) == 0x11) &&
- (*(s + 8) == 0xA6) &&
- (*(s + 9) == 0xD9) &&
- (*(s + 10) == 0x00) &&
- (*(s + 11) == 0xAA) &&
- (*(s + 12) == 0x00) &&
- (*(s + 13) == 0x62) &&
- (*(s + 14) == 0xCE) &&
- (*(s + 15) == 0x6C) ) {
+ if ((*(s + 0) == 0x30) &&
+ (*(s + 1) == 0x26) &&
+ (*(s + 2) == 0xB2) &&
+ (*(s + 3) == 0x75) &&
+ (*(s + 4) == 0x8E) &&
+ (*(s + 5) == 0x66) &&
+ (*(s + 6) == 0xCF) &&
+ (*(s + 7) == 0x11) &&
+ (*(s + 8) == 0xA6) &&
+ (*(s + 9) == 0xD9) &&
+ (*(s + 10) == 0x00) &&
+ (*(s + 11) == 0xAA) &&
+ (*(s + 12) == 0x00) &&
+ (*(s + 13) == 0x62) &&
+ (*(s + 14) == 0xCE) &&
+ (*(s + 15) == 0x6C)) {
return 1;
}
return 0;
}
-static int _MMFileIsAMRHeader (void *header)
+static int _MMFileIsAMRHeader(void *header)
{
#define _MMFILE_AMR_SINGLE_CH_HEADER_SIZE 6
#define _MMFILE_AMR_SINGLE_CH_HEADER "#!AMR\n"
unsigned char *s = header;
- if (!memcmp (s, _MMFILE_AMR_SINGLE_CH_HEADER, _MMFILE_AMR_SINGLE_CH_HEADER_SIZE) ||
- !memcmp (s, _MMFILE_AMR_WB_SINGLE_CH_HEADER, _MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE) ||
- !memcmp (s, _MMFILE_AMR_MULTI_CH_HEADER, _MMFILE_AMR_MULTI_CH_HEADER_SIZE) ||
- !memcmp (s, _MMFILE_AMR_WB_MULTI_CH_HEADER, _MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE)) {
+ if (!memcmp(s, _MMFILE_AMR_SINGLE_CH_HEADER, _MMFILE_AMR_SINGLE_CH_HEADER_SIZE) ||
+ !memcmp(s, _MMFILE_AMR_WB_SINGLE_CH_HEADER, _MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE) ||
+ !memcmp(s, _MMFILE_AMR_MULTI_CH_HEADER, _MMFILE_AMR_MULTI_CH_HEADER_SIZE) ||
+ !memcmp(s, _MMFILE_AMR_WB_MULTI_CH_HEADER, _MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE)) {
return 1;
}
return 0;
}
-static int _MMFileIsIMYHeader (void *header)
+static int _MMFileIsIMYHeader(void *header)
{
unsigned char *s = header;
return 0;
}
-static int _MMFileIsMIDHeader (void *header)
+static int _MMFileIsMIDHeader(void *header)
{
unsigned char *s = header;
if (!memcmp(s, "MThd", 4)) { /*general MIDI*/
return 1;
- } else if (!memcmp (s, "XMF_", 4)) { /*XMF*/
+ } else if (!memcmp(s, "XMF_", 4)) { /*XMF*/
return 1;
} else if (!memcmp(s, "IREZ", 4)) {
return 1; /*RMF format*/
return 0;
}
-static int _MMFileIsMMFHeader (void *header)
+static int _MMFileIsMMFHeader(void *header)
{
#define _MMFILE_MMF_TYPE_POSITION ((char)0x11)
unsigned char *s = header;
- if(!memcmp (s, "MMMD", 4)) {
+ if (!memcmp(s, "MMMD", 4)) {
/* warning: comparison is always true due to limited range of data type */
- if( *(s + _MMFILE_MMF_TYPE_POSITION) <= 0x2F ) {
+ if (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x2F) {
return 1;
- } else if (((*(s + _MMFILE_MMF_TYPE_POSITION) >= 0x30) && (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x38)) // MA3, MA5 type
- || ((*(s + _MMFILE_MMF_TYPE_POSITION) >= 0x40) && (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x48))
- || ((*(s + _MMFILE_MMF_TYPE_POSITION) >= 0x50) && (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x58))
- || ((*(s + _MMFILE_MMF_TYPE_POSITION) == 0xF0))) {
+ } else if (((*(s + _MMFILE_MMF_TYPE_POSITION) >= 0x30) && (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x38)) /* MA3, MA5 type */
+ || ((*(s + _MMFILE_MMF_TYPE_POSITION) >= 0x40) && (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x48))
+ || ((*(s + _MMFILE_MMF_TYPE_POSITION) >= 0x50) && (*(s + _MMFILE_MMF_TYPE_POSITION) <= 0x58))
+ || ((*(s + _MMFILE_MMF_TYPE_POSITION) == 0xF0))) {
return 1;
}
}
-static int _MMFileIsAVIHeader (void *header)
+static int _MMFileIsAVIHeader(void *header)
{
unsigned char *s = header;
- if (!memcmp(s, "RIFF", 4) && !memcmp(s+8, "AVI", 3)) {
+ if (!memcmp(s, "RIFF", 4) && !memcmp(s + 8, "AVI", 3)) {
return 1;
}
}
-static int _MMFileIsWAVHeader (void *header)
+static int _MMFileIsWAVHeader(void *header)
{
unsigned char *s = header;
- if (!memcmp(s, "RIFF", 4) && !memcmp(s+8, "WAVE", 4)) {
+ if (!memcmp(s, "RIFF", 4) && !memcmp(s + 8, "WAVE", 4)) {
return 1;
}
-static int _MMFileIsMP4Header (void *header)
+static int _MMFileIsMP4Header(void *header)
{
unsigned char *s = header;
- if (!memcmp (s, "moov", 4) ||
- !memcmp (s, "mdat", 4) ||
- !memcmp (s, "ftyp", 4) ||
- !memcmp (s, "free", 4) ||
- !memcmp (s, "uuid", 4) ||
- !memcmp (s, "skip", 4) ||
-
- !memcmp (s, "PICT", 4) ||
- !memcmp (s, "wide", 4) ||
- !memcmp (s, "prfl", 4)) {
+ if (!memcmp(s, "moov", 4) ||
+ !memcmp(s, "mdat", 4) ||
+ !memcmp(s, "ftyp", 4) ||
+ !memcmp(s, "free", 4) ||
+ !memcmp(s, "uuid", 4) ||
+ !memcmp(s, "skip", 4) ||
+
+ !memcmp(s, "PICT", 4) ||
+ !memcmp(s, "wide", 4) ||
+ !memcmp(s, "prfl", 4)) {
return 1;
}
return 0;
}
-static int _MMFileIsOGGHeader (void *header)
+static int _MMFileIsOGGHeader(void *header)
{
unsigned char *s = header;
return 0;
}
-static int _MMFileIsREALHeader (void *header)
+static int _MMFileIsREALHeader(void *header)
{
unsigned char *s = header;
- if (!memcmp (s, ".RMF", 4)) {
- return 1;
- }
+ if (!memcmp(s, ".RMF", 4)) {
+ return 1;
+ }
return 0;
}
-static int _MMFileIsMPEGTSHeader (MMFileIOHandle *fp)
+static int _MMFileIsMPEGTSHeader(MMFileIOHandle *fp)
{
- unsigned char header[TS_MAX_PACKET_SIZE] = {0,};
- unsigned char *s = NULL;
+ unsigned char header[TS_MAX_PACKET_SIZE] = {0, };
+ unsigned char *s = NULL;
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
mmfile_read(fp, header, sizeof(header));
s = (unsigned char *)memchr(header, 0x47, sizeof(header));
- if(s) {
- unsigned char buffer[TS_PACKET_SIZE] = {0,};
+ if (s) {
+ unsigned char buffer[TS_PACKET_SIZE] = {0, };
unsigned int startoffset = s - header + 1;
mmfile_seek(fp, startoffset, MMFILE_SEEK_SET);
mmfile_read(fp, buffer, sizeof(buffer));
- if(buffer[sizeof(buffer)-1] & 0x47) {
+ if (buffer[sizeof(buffer) - 1] & 0x47) {
return MPEGTS_PACKET;
} else {
- unsigned char buffer[TS_DVHS_PACKET_SIZE] = {0,};
+ unsigned char dvhs_buf[TS_DVHS_PACKET_SIZE] = {0, };
- mmfile_seek (fp, startoffset, MMFILE_SEEK_SET);
- mmfile_read (fp, buffer, sizeof(buffer));
+ mmfile_seek(fp, startoffset, MMFILE_SEEK_SET);
+ mmfile_read(fp, dvhs_buf, sizeof(dvhs_buf));
- if(buffer[sizeof(buffer)-1] & 0x47) {
+ if (dvhs_buf[sizeof(dvhs_buf) - 1] & 0x47) {
return MPEGTS_DVHS;
} else {
- unsigned char buffer[TS_FEC_PACKET_SIZE] = {0,};
+ unsigned char fec_buf[TS_FEC_PACKET_SIZE] = {0, };
mmfile_seek(fp, startoffset, MMFILE_SEEK_SET);
- mmfile_read(fp, buffer, sizeof(buffer));
+ mmfile_read(fp, fec_buf, sizeof(fec_buf));
- if(buffer[sizeof(buffer)-1] & 0x47) {
+ if (fec_buf[sizeof(fec_buf) - 1] & 0x47) {
return MPEGTS_FECE;
}
}
return MPEGTS_NONE;
}
-static int _MMFileIsMPEGPSHeader (void *header)
+static int _MMFileIsMPEGPSHeader(void *header)
{
unsigned char *s = header;
if ((*(s + 0) == 0x00) &&
- (*(s + 1) == 0x00) &&
- (*(s + 2) == 0x01) &&
- (*(s + 3) == 0xba)) { // mpeg-ps header
+ (*(s + 1) == 0x00) &&
+ (*(s + 2) == 0x01) &&
+ (*(s + 3) == 0xba)) { /* mpeg-ps header */
return 1;
}
return 0;
}
-static int _MMFileIsMPEGAUDIOHeader (void *header)
+static int _MMFileIsMPEGAUDIOHeader(void *header)
{
unsigned char *s = header;
- if ((*(s + 0) & 0xFF) &&
- (*(s + 1) & 0xFE)){ // mpeg audio layer 1 header
+ if ((*(s + 0) & 0xFF) &&
+ (*(s + 1) & 0xFE)) { /* mpeg audio layer 1 header */
return 1;
}
return 0;
}
-static int _MMFileIsMPEGVIDEOHeader (void *header)
+static int _MMFileIsMPEGVIDEOHeader(void *header)
{
unsigned char *s = header;
if ((*(s + 0) == 0x00) &&
- (*(s + 1) == 0x00) &&
- (*(s + 2) == 0x01) &&
- (*(s + 3) == 0xb3)) { // mpeg1 video header
+ (*(s + 1) == 0x00) &&
+ (*(s + 2) == 0x01) &&
+ (*(s + 3) == 0xb3)) { /* mpeg1 video header */
return 1;
}
return 0;
}
-static int _MMFileIsMP3Header (void *header)
+static int _MMFileIsMP3Header(void *header)
{
unsigned long head = 0;
unsigned char *headc = header;
- unsigned int bitrate, layer, length, mode;
- unsigned int coef,samplerate, version, channels;
+ unsigned int bitrate, layer, length/*, mode*/;
+ unsigned int coef, samplerate, version/*, channels*/;
static const unsigned int mp3types_bitrates[2][3][16] = {
{ {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},
{0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},
- {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}},
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}
+ },
{ {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},
- {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}},
+ {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}
+ },
};
static const unsigned int mp3types_freqs[3][3] = {
{44100, 48000, 32000}
};
- static const unsigned int mp3FrameCoef[4][4] = {{-1,48,144,72},{-1,-1,-1,-1},{-1,48,144,72},{-1,48,144,144}};
+ static const unsigned int mp3FrameCoef[4][4] = {
+ { -1, 48, 144, 72},
+ { -1, -1, -1, -1},
+ { -1, 48, 144, 72},
+ { -1, 48, 144, 144}
+ };
/* header */
- head = (*(headc+0)<<24 | *(headc+1)<<16 | *(headc+2)<<8 | *(headc+3));
+ head = (*(headc + 0) << 24 | *(headc + 1) << 16 | *(headc + 2) << 8 | *(headc + 3));
if ((head & 0xffe00000) != 0xffe00000) {
- return 0;
+ return 0;
}
/* we don't need extension, copyright, original or
head >>= 6;
/* mode */
- mode = head & 0x3;
+ /*mode = head & 0x3;*/
head >>= 3;
/* padding */
/* bitrate index */
bitrate = head & 0xF;
-
+
if (bitrate == 15) {
return 0;
}
}
/* lookup */
- channels = (mode == 3) ? 1 : 2;
+ /*channels = (mode == 3) ? 1 : 2;*/
samplerate = mp3types_freqs[version > 0 ? version - 1 : 0][samplerate];
{
/* calculating */
bitrate = mp3types_bitrates[version == 3 ? 0 : 1][layer - 1][bitrate];
coef = mp3FrameCoef[version][layer];
- if(layer == 1)
- length = length*4;
+ if (layer == 1)
+ length = length * 4;
- length = length + ((coef*bitrate*1000)/samplerate);
+ length = length + ((coef * bitrate * 1000) / samplerate);
}
return length;
}
-static int _MMFileSearchID3Tag (MMFileIOHandle *fp, unsigned int *offset)
+static int _MMFileSearchID3Tag(MMFileIOHandle *fp, unsigned int *offset)
{
#define _MMFILE_MP3_TAGV2_HEADER_LEN 10
-#define _MMFILE_GET_INT_NUMBER(buff) (int)( (((int)(buff)[0]) << 24) | (((int)(buff)[1]) << 16) | (((int)(buff)[2]) << 8) | (((int)(buff)[3])))
+#define _MMFILE_GET_INT_NUMBER(buff) (int)((((int)(buff)[0]) << 24) | (((int)(buff)[1]) << 16) | (((int)(buff)[2]) << 8) | (((int)(buff)[3])))
- unsigned char tagHeader[_MMFILE_MP3_TAGV2_HEADER_LEN] = {0,};
+ unsigned char tagHeader[_MMFILE_MP3_TAGV2_HEADER_LEN] = {0, };
unsigned int tagInfoSize = 0;
unsigned int acc_tagsize = 0;
int tagVersion = 0;
*offset = 0;
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
-
+
_START_TAG_SEARCH:
- readed = mmfile_read (fp, tagHeader, _MMFILE_MP3_TAGV2_HEADER_LEN);
+ readed = mmfile_read(fp, tagHeader, _MMFILE_MP3_TAGV2_HEADER_LEN);
if (readed != _MMFILE_MP3_TAGV2_HEADER_LEN) {
- debug_error ("read error occured.\n");
+ debug_error("read error occured.\n");
return 0;
}
- if (memcmp (tagHeader, "ID3", 3) == 0) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("'ID3' found.\n");
- #endif
+ if (memcmp(tagHeader, "ID3", 3) == 0) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("'ID3' found.\n");
+#endif
} else {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("'ID3' not found.\n");
- #endif
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("'ID3' not found.\n");
+#endif
goto search_end;
}
/**@note weak id3v2 tag checking*/
if (tagHeader[3] != 0xFF && tagHeader[4] != 0xFF &&
- (tagHeader[6] & 0x80) == 0 && (tagHeader[7] & 0x80) == 0 &&
- (tagHeader[8] & 0x80) == 0 && (tagHeader[9] & 0x80) == 0) {
- #ifdef __MMFILE_TEST_MODE__
- debug_msg ("good ID3V2 tag.\n");
- #endif
+ (tagHeader[6] & 0x80) == 0 && (tagHeader[7] & 0x80) == 0 &&
+ (tagHeader[8] & 0x80) == 0 && (tagHeader[9] & 0x80) == 0) {
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("good ID3V2 tag.\n");
+#endif
} else {
- debug_warning ("It's bad ID3V2 tag.\n");
+ debug_warning("It's bad ID3V2 tag.\n");
goto search_end;
}
tagVersion = tagHeader[3];
if (tagVersion > 4) {
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("Tag version not supported\n");
- #endif
+#endif
goto search_end;
}
/**@note unfortunately, some contents has many id3 tag.*/
acc_tagsize += tagInfoSize;
- #ifdef __MMFILE_TEST_MODE__
+#ifdef __MMFILE_TEST_MODE__
debug_msg("tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
- #endif
+#endif
mmfile_seek(fp, acc_tagsize, MMFILE_SEEK_SET);
*offset = acc_tagsize;
return ret;
}
-static int _MMFileIsFLACHeader (void *header)
+static int _MMFileIsFLACHeader(void *header)
{
unsigned char *s = header;
return 0;
}
-static int _MMFileIsFLVHeader (void *header)
+static int _MMFileIsFLVHeader(void *header)
{
unsigned char *s = header;
projects / platform / core / multimedia / libmm-fileinfo.git / commitdiff