EXPORT_API
int mmfile_codec_open_dummy(MMFileCodecContext *codecContext, MMFileCodecFrame *input)
{
- debug_warning("called mmfile_codec_open_dummy\n");
+ debug_warning(DEBUG, "called mmfile_codec_open_dummy\n");
codecContext->Decode = mmfile_codec_decode_dummy;
codecContext->Close = mmfile_codec_close_dummy;
EXPORT_API
int mmfile_codec_decode_dummy(MMFileCodecContext *codecContext, MMFileCodecFrame *output)
{
- debug_warning("called mmfile_codec_decode_dummy\n");
+ debug_warning(DEBUG, "called mmfile_codec_decode_dummy\n");
return MMFILE_CODEC_SUCCESS;
}
EXPORT_API
int mmfile_codec_close_dummy(MMFileCodecContext *codecContext)
{
- debug_warning("called mmfile_codec_close_dummy\n");
+ debug_warning(DEBUG, "called mmfile_codec_close_dummy\n");
codecContext->Decode = NULL;
codecContext->Close = 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");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_CODEC_FAIL;
}
if (NULL == OpenVideoCodecFunc[codecId]) {
- debug_error("error: Not implemented \n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "error: mmfile_malloc fail for codecObject\n");
return MMFILE_CODEC_FAIL;
}
ret = OpenVideoCodecFunc[codecId](codecObject, input);
if (MMFILE_CODEC_FAIL == ret) {
- debug_error("error: init fail about video codec\n");
+ debug_error(DEBUG, "error: init fail about video codec\n");
ret = MMFILE_CODEC_FAIL;
goto exception;
}
int mmfile_codec_decode(MMFileCodecContext *codecContext, MMFileCodecFrame *output)
{
if (NULL == codecContext || NULL == codecContext->Decode) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_CODEC_FAIL;
}
int mmfile_codec_close(MMFileCodecContext *codecContext)
{
if (NULL == codecContext || NULL == codecContext->Close) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_CODEC_FAIL;
}
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");
-#endif
+ debug_msg(RELEASE, "Read Fail");
return MMFILE_AAC_PARSER_FAIL;
}
if (!IS_ID3V2_TAG(tagHeader)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("No ID3 Tag");
-#endif
+ debug_msg(RELEASE, "No ID3 Tag");
goto search_end;
}
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");
-#endif
+ debug_msg(RELEASE, "Read Fail");
return MMFILE_AAC_PARSER_FAIL;
}
pData->tagVersion = tagHeader[3];
if (pData->tagVersion > 4) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("\nTag version not supported");
-#endif
+ debug_msg(RELEASE, "\nTag version not supported");
return MMFILE_AAC_PARSER_FAIL;
}
((encSize & 0x007F0000) >> 2) | ((encSize & 0x7F000000) >> 3));
if (pData->tagInfoSize > pData->streamInfo.fileSize) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Invalid size");
-#endif
+ debug_msg(RELEASE, "Invalid size");
return MMFILE_AAC_PARSER_FAIL;
}
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);
+ debug_error(DEBUG, "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);
+ debug_error(DEBUG, "failed to read. %d, %lld\n", readed, hTag->fileLen);
goto failure;
}
ret = mm_file_id3tag_parse_v224(hTag, tagBuff);
break;
default:
- debug_error("Invalid Tag version [%d]\n", hTag->tagV2Info.tagVersion);
+ debug_error(DEBUG, "Invalid Tag version [%d]\n", hTag->tagV2Info.tagVersion);
break;
}
if (ret == FALSE) {
ret = MMFILE_AAC_PARSER_FAIL;
- debug_warning("failed to parse\n");
+ debug_warning(DEBUG, "failed to parse\n");
goto failure;
}
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",
+ debug_msg(RELEASE, "\nFILE POS: %lld\n", filePosBefore);
+ debug_msg(RELEASE, "\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;
int readed = 0;
if (NULL == filenamec) {
- debug_error("file source is NULL\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exception;
}
/* 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");
+ debug_error(RELEASE, "Error in searching the ID3 tag\n");
goto exception;
}
if (IS_AAC_ADIF_HEADER(header)) {
privateData->formatType = AAC_FORMAT_ADIF;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("AAC Format: ADIF\n");
-#endif
+ debug_msg(RELEASE, "AAC Format: ADIF\n");
} else if (IS_AAC_ADTS_HEADER(header)) {
privateData->formatType = AAC_FORMAT_ADTS;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("AAC Format: ADTS\n");
-#endif
+ debug_msg(RELEASE, "AAC Format: ADTS\n");
/* 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");
+ debug_error(DEBUG, "Invalid Frame length in ADTS header\n");
goto exception;
}
} else {
privateData->formatType = AAC_FORMAT_UNKNOWN;
- debug_error("AAC Format: UNKNOWN\n");
+ debug_error(DEBUG, "AAC Format: UNKNOWN\n");
goto exception;
}
int ret = MMFILE_AAC_PARSER_SUCCESS;
if (NULL == handle || NULL == aacinfo) {
- debug_error("handle is NULL\n");
+ debug_error(DEBUG, "handle is NULL\n");
return MMFILE_AAC_PARSER_FAIL;
}
}
if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("Error in parsing the stream header\n");
+ debug_error(DEBUG, "Error in parsing the stream header\n");
return ret;
}
}
if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("Found corrupted frames!!! Ignoring\n");
+ debug_error(DEBUG, "Found corrupted frames!!! Ignoring\n");
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("No of ADTS frames: %d\n", totalFrames);
-#endif
+ debug_msg(RELEASE, "No of ADTS frames: %d\n", totalFrames);
+
privateData->streamInfo.frameRate = privateData->streamInfo.samplingRate / AAC_ADTS_SAMPLES_PER_FRAME;
if (privateData->streamInfo.frameRate)
int ret = 0;
if (NULL == handle || NULL == tagInfo) {
- debug_error("handle is NULL\n");
+ debug_error(DEBUG, "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");
+ debug_warning(DEBUG, "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");
+ debug_warning(DEBUG, "Error in parsing the Tag info\n");
return ret;
}
tMMFILE_AAC_HANDLE *privateData = NULL;
if (NULL == handle) {
- debug_error("handle is NULL\n");
+ debug_error(DEBUG, "handle is NULL\n");
return MMFILE_AAC_PARSER_FAIL;
}
int res = MMFILE_FORMAT_FAIL;
if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error("error: mmfile_format_open_aac\n");
+ debug_error(DEBUG, "error: mmfile_format_open_aac\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
res = MMFileFormatIsValidAAC(NULL, formatContext->uriFileName);
if (res == 0) {
- debug_error("It is not AAC file\n");
+ debug_error(DEBUG, "It is not AAC file\n");
return MMFILE_FORMAT_FAIL;
}
}
res = mmfile_aacparser_open(&handle, formatContext->uriFileName);
if (MMFILE_AAC_PARSER_FAIL == res) {
- debug_error("mmfile_aacparser_open\n");
+ debug_error(DEBUG, "mmfile_aacparser_open\n");
return MMFILE_FORMAT_FAIL;
}
int ret = MMFILE_FORMAT_FAIL;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
ret = mmfile_aacparser_get_stream_info(handle, &aacinfo);
if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error("error: mmfile_aacparser_get_stream_info\n");
+ debug_error(DEBUG, "error: mmfile_aacparser_get_stream_info\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error("error: calloc_audiostream\n");
+ debug_error(DEBUG, "error: calloc_audiostream\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
int ret = MMFILE_FORMAT_FAIL;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
ret = mmfile_aacparser_get_tag_info(handle, &aacinfo);
if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_warning("error: mmfile_aacparser_get_tag_info\n");
+ debug_warning(DEBUG, "error: mmfile_aacparser_get_tag_info\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
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(DEBUG, "error: mmfile_format_read_frame_aac, no handling\n");
return MMFILE_FORMAT_FAIL;
}
int ret = MMFILE_FORMAT_FAIL;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
if (NULL != handle) {
ret = mmfile_aacparser_close(handle);
if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error("error: mmfile_format_close_aac\n");
+ debug_error(DEBUG, "error: mmfile_format_close_aac\n");
}
}
return MMFILE_AMR_PARSER_FAIL;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("\nAMR HEADER: [%2x] [%2x] [%2x] [%2x] [%2x]\n \
+ debug_msg(RELEASE, "\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]);
-#endif
if (!(memcmp(header, MMFILE_AMR_SINGLE_CH_HEADER, MMFILE_AMR_SINGLE_CH_HEADER_SIZE))) {
pData->amrFormat = AMR_FORMAT_NB;
buf = mmfile_malloc(AMR_MAX_READ_BUF_SZ);
if (!buf) {
- debug_error("failed to memory allocaion.\n");
+ debug_error(DEBUG, "failed to memory allocaion.\n");
return MMFILE_AMR_PARSER_FAIL;
}
int ret = 0;
if (NULL == filenamec || NULL == handle) {
- debug_error("file source is NULL\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "file source is NULL\n");
return MMFILE_AMR_PARSER_FAIL;
}
ret = mmfile_open(&privateData->hFile, filenamec, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exception;
}
mmfile_seek(privateData->hFile, 0, MMFILE_SEEK_SET);
if (privateData->fileSize < MMFILE_AMR_MIN_HEADER_SIZE) {
- debug_error("Too small file to parse!!\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "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*/
+ debug_error(DEBUG, "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", \
+ debug_msg(RELEASE, "AMR Format Type: %s\n", \
privateData->amrFormat == AMR_FORMAT_NB ? "AMR-NB" : "AMR-WB");
-#endif
*handle = privateData;
int ret;
if (NULL == handle || NULL == amrinfo) {
- debug_error("handle is NULL\n");
+ debug_error(DEBUG, "handle is NULL\n");
return MMFILE_AMR_PARSER_FAIL;
}
ret = _parse_amr_stream(privateData);
if (ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error("Error in parsing the stream\n");
+ debug_error(DEBUG, "Error in parsing the stream\n");
return ret;
}
tMMFILE_AMR_HANDLE *privateData = NULL;
if (NULL == handle) {
- debug_error("handle is NULL\n");
+ debug_error(DEBUG, "handle is NULL\n");
return MMFILE_AMR_PARSER_FAIL;
}
int res = MMFILE_FORMAT_FAIL;
if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error("error: mmfile_format_open_amr\n");
+ debug_error(DEBUG, "error: mmfile_format_open_amr\n");
return MMFILE_FORMAT_FAIL;
}
res = mmfile_amrparser_open(&handle, formatContext->uriFileName);
if (MMFILE_AMR_PARSER_FAIL == res) {
- debug_error("mmfile_amrparser_open\n");
+ debug_error(DEBUG, "mmfile_amrparser_open\n");
return MMFILE_FORMAT_FAIL;
}
int ret = MMFILE_FORMAT_FAIL;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
ret = mmfile_amrparser_get_stream_info(handle, &amrinfo);
if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error("error: mmfile_amrparser_get_stream_info\n");
+ debug_error(DEBUG, "error: mmfile_amrparser_get_stream_info\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error("error: calloc_audiostream\n");
+ debug_error(DEBUG, "error: calloc_audiostream\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
int mmfile_format_read_frame_amr(MMFileFormatContext *formatContext,
unsigned int timestamp, MMFileFormatFrame *frame)
{
- debug_error("error: mmfile_format_read_frame_amr, no handling\n");
+ debug_error(DEBUG, "error: mmfile_format_read_frame_amr, no handling\n");
return MMFILE_FORMAT_FAIL;
}
int ret = MMFILE_FORMAT_FAIL;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
if (NULL != handle) {
ret = mmfile_amrparser_close(handle);
if (ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error("error: mmfile_format_close_amr\n");
+ debug_error(DEBUG, "error: mmfile_format_close_amr\n");
}
}
EXPORT_API
int mmfile_format_open_dummy(MMFileFormatContext *formatContext)
{
- debug_warning("called mmfile_format_open_dummy\n");
+ debug_warning(DEBUG, "called mmfile_format_open_dummy\n");
formatContext->ReadStream = mmfile_format_read_stream_dummy;
formatContext->ReadFrame = mmfile_format_read_frame_dummy;
EXPORT_API
int mmfile_format_read_stream_dummy(MMFileFormatContext *formatContext)
{
- debug_warning("called mmfile_format_read_stream_dummy\n");
+ debug_warning(DEBUG, "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)
{
- debug_warning("called mmfile_format_read_frame_dummy\n");
+ debug_warning(DEBUG, "called mmfile_format_read_frame_dummy\n");
return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
int mmfile_format_read_tag_dummy(MMFileFormatContext *formatContext)
{
- debug_warning("called mmfile_format_read_tag_dummy\n");
+ debug_warning(DEBUG, "called mmfile_format_read_tag_dummy\n");
return MMFILE_FORMAT_SUCCESS;
}
EXPORT_API
int mmfile_format_close_dummy(MMFileFormatContext *formatContext)
{
- debug_warning("called mmfile_format_close_dummy\n");
+ debug_warning(DEBUG, "called mmfile_format_close_dummy\n");
if (formatContext) {
formatContext->ReadStream = NULL;
formatContext->ReadFrame = NULL;
formatContext->ReadTag = mmfile_format_read_tag_ffmpg;
formatContext->Close = mmfile_format_close_ffmpg;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("ffmpeg version: %d\n", avformat_version());
+ debug_msg(RELEASE, "ffmpeg version: %d\n", avformat_version());
/**
* FFMPEG DEBUG LEVEL
* AV_LOG_QUIET -1
* AV_LOG_VERBOSE 1
* AV_LOG_DEBUG 2
*/
+#ifdef __MMFILE_TEST_MODE__
av_log_set_level(AV_LOG_DEBUG);
#else
av_log_set_level(AV_LOG_QUIET);
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");
+ debug_error(DEBUG, "error: Error in MIME Type finding\n");
return MMFILE_FORMAT_FAIL;
}
ret = mmfile_util_get_ffmpeg_format(mimeType, ffmpegFormatName);
if (MMFILE_UTIL_SUCCESS != ret) {
- debug_error("error: mmfile_util_get_ffmpeg_format\n");
+ debug_error(DEBUG, "error: mmfile_util_get_ffmpeg_format\n");
return MMFILE_FORMAT_FAIL;
}
grab_iformat = av_find_input_format(ffmpegFormatName);
if (NULL == grab_iformat) {
- debug_error("error: cannot find format\n");
+ debug_error(DEBUG, "error: cannot find format\n");
goto exception;
}
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);
+ debug_error(DEBUG, "error: cannot open %s %d\n", formatContext->uriFileName, ret);
goto exception;
}
formatContext->privateFormatData = pFormatCtx;
ret = av_open_input_file(&pFormatCtx, formatContext->filesrc->file.path, NULL, 0, NULL);
#endif
if (ret < 0) {
- debug_error("error: cannot open %s %d\n", formatContext->filesrc->file.path, ret);
+ debug_error(DEBUG, "error: cannot open %s %d\n", formatContext->filesrc->file.path, ret);
goto exception;
}
}
if (!pFormatCtx/* || !(pFormatCtx->nb_streams > 0)*/) {
- debug_warning("failed to find av stream. maybe corrupted data.\n");
+ debug_warning(DEBUG, "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
+ debug_msg(RELEASE, "number of stream: %d\n", pFormatCtx->nb_streams);
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 0;
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
+ debug_msg(RELEASE, "FFMPEG video codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
AVPacket pkt = pFormatCtx->streams[i]->attached_pic;
if ((pkt.data != NULL) && (pkt.size > 0))
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
+ debug_msg(RELEASE, "FFMPEG audio codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
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
+ debug_msg(RELEASE, "FFMPEG video codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
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
+ debug_msg(RELEASE, "FFMPEG audio codec id: 0x%08X\n", pFormatCtx->streams[i]->codec->codec_id);
formatContext->audioTotalTrackNum += 1;
}
#endif
}
+ debug_msg(RELEASE, "format: %s (%s)\n", pFormatCtx->iformat->name, pFormatCtx->iformat->long_name);
#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
{
bool ret = FALSE;
-#ifdef __MMFILE_TEST_MODE__
- debug_error("[sample rate %d, sample format %d]", sample_rate, sample_fmt_info);
-#endif
+ debug_error(RELEASE, "[sample rate %d, sample format %d]", sample_rate, sample_fmt_info);
if ((sample_rate >= 44100) && (sample_fmt_info >= AV_SAMPLE_FMT_S32)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("UHQA CONTENT");
-#endif
+ debug_msg(RELEASE, "UHQA CONTENT");
ret = TRUE;
} else {
ret = FALSE;
int ret = 0;
if (NULL == formatContext || NULL == formatContext->privateFormatData) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_FORMAT_FAIL;
}
ret = av_find_stream_info(pFormatCtx);
#endif
if (ret < 0) {
- debug_warning("failed to find stream info. errcode = %d\n", ret);
+ debug_warning(DEBUG, "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
+ debug_msg(RELEASE, "FFMPEG: dur %lld, start %lld\n", pFormatCtx->duration, pFormatCtx->start_time);
/**
*@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);
+ debug_warning(DEBUG, "Wrong Start time = %lld\n", pFormatCtx->start_time);
formatContext->duration = (long long)(pFormatCtx->duration) * 1000 / AV_TIME_BASE;
} else {
formatContext->duration = (long long)(pFormatCtx->duration + pFormatCtx->start_time) * 1000 / AV_TIME_BASE;
if (formatContext->videoStreamId == -1) {
videoStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == videoStream) {
- debug_error("mmfile_malloc error\n");
+ debug_error(DEBUG, "mmfile_malloc error\n");
goto exception;
}
if (pVideoCodecCtx) {
videoStream->codecId = ConvertVideoCodecEnum(pVideoCodecCtx->codec_id);
if (videoStream->codecId == MM_VIDEO_CODEC_NONE) {
- debug_error("Proper codec is not found in [%d] stream", i);
+ debug_error(RELEASE, "Proper codec is not found in [%d] stream", i);
formatContext->videoStreamId = -1;
mmfile_free(videoStream);
formatContext->streams[MMFILE_VIDEO_STREAM] = NULL;
if (formatContext->audioStreamId == -1) {
audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error("mmfile_malloc error\n");
+ debug_error(DEBUG, "mmfile_malloc error\n");
goto exception;
}
}
if (formatContext->nbStreams == 0) {
- debug_error("error: there is no audio and video track\n");
+ debug_error(DEBUG, "error: there is no audio and video track\n");
goto exception;
}
AVFormatContext *pFormatCtx = NULL;
if (NULL == formatContext || NULL == formatContext->privateFormatData) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_FORMAT_FAIL;
}
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(DEBUG, "Unknown cover type: 0x%x\n", codec_id);
/*Copy artwork*/
if (formatContext->artwork) mmfile_free(formatContext->artwork);
g_free(meta_data);
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_log("Not support metadata. [%s:%s]", tag->key, tag->value);
-#endif
+ debug_log(RELEASE, "Not support metadata. [%s:%s]", tag->key, tag->value);
}
}
}
NULL == formatContext->privateFormatData ||
formatContext->videoTotalTrackNum <= 0) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\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(DEBUG, "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");
+ debug_error(DEBUG, "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 & 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
+ debug_msg(RELEASE, "flag: 0x%08X\n", pVideoCodec->capabilities);
+ /* debug_msg(RELEASE, " DRAW_HORIZ_BAND : %d\n", pVideoCodec->capabilities & CODEC_CAP_DRAW_HORIZ_BAND ? 1 : 0); */
+ /* debug_msg(RELEASE, " DR1 : %d\n", pVideoCodec->capabilities & CODEC_CAP_DR1 ? 1 : 0); */
+ /* debug_msg(RELEASE, " PARSE_ONLY : %d\n", pVideoCodec->capabilities & CODEC_CAP_PARSE_ONLY ? 1 : 0); */
+ /* debug_msg(RELEASE, " TRUNCATED : %d\n", pVideoCodec->capabilities & CODEC_CAP_TRUNCATED ? 1 : 0); */
+ /* debug_msg(RELEASE, " HWACCEL : %d\n", pVideoCodec->capabilities & CODEC_CAP_HWACCEL ? 1 : 0); */
+ /* debug_msg(RELEASE, " DELAY : %d\n", pVideoCodec->capabilities & CODEC_CAP_DELAY ? 1 : 0); */
+ /* debug_msg(RELEASE, " SMALL_LAST_FRAME: %d\n", pVideoCodec->capabilities & CODEC_CAP_SMALL_LAST_FRAME ? 1 : 0); */
+ /* debug_msg(RELEASE, " HWACCEL_VDPAU : %d\n", pVideoCodec->capabilities & CODEC_CAP_HWACCEL_VDPAU ? 1 : 0); */
if (pVideoCodec->capabilities & CODEC_CAP_TRUNCATED) {
pVideoCodecCtx->flags |= CODEC_FLAG_TRUNCATED;
ret = avcodec_open(pVideoCodecCtx, pVideoCodec);
#endif
if (ret < 0) {
- debug_error("error: avcodec_open fail.\n");
+ debug_error(DEBUG, "error: avcodec_open fail.\n");
return MMFILE_FORMAT_FAIL;
}
pFrameRGB = av_frame_alloc();
if (!pFrameRGB) {
- debug_error("error: pFrame or pFrameRGB is NULL\n");
+ debug_error(DEBUG, "error: pFrame or pFrameRGB is NULL\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* 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");
+ debug_error(DEBUG, "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
+ debug_msg(RELEASE, "Video default resolution = [%dx%d]\n", pVideoCodecCtx->coded_width, pVideoCodecCtx->coded_height);
+ debug_msg(RELEASE, "Video coded resolution = [%dx%d]\n", pVideoCodecCtx->width, pVideoCodecCtx->height);
/*sometimes, ffmpeg's width/height is wrong*/
#if 0 /*coded_width/height sometimes wrong. so use width/height*/
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(DEBUG, "error: avpicture_get_size. [%d x %d]\n", width, height);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
frame->frameData = mmfile_malloc(numBytes);
if (NULL == frame->frameData) {
- debug_error("error: avpicture_get_size. [%d]\n", numBytes);
+ debug_error(DEBUG, "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);
if (ret < 0) {
- debug_error("error: avpicture_fill fail. errcode = 0x%08X\n", ret);
+ debug_error(DEBUG, "error: avpicture_fill fail. errcode = 0x%08X\n", ret);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
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(DEBUG, "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");
+ debug_error(DEBUG, "failed to convet image\n");
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");
+ debug_error(DEBUG, "failed to convet image\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
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
+ debug_msg(RELEASE, "checking frame. %p, %d, %d, %d\n", buf, wrap, xsize, ysize);
/*if too small, always ok return.*/
if (ysize < _MM_CHUNK_NUM)
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
+ debug_msg(RELEASE, "check %04d line. %s [%d]\n", i, (is_different == 0 ? "same" : "different"), is_different);
if (point >= _MM_CHUNK_LIMIT) {
if (sum_diff > _MM_CHUNK_DIFF_LIMIT) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Good :-)\n");
-#endif
+ debug_msg(RELEASE, "Good :-)\n");
return 1;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Bad :-(\n");
-#endif
+ debug_msg(RELEASE, "Bad :-(\n");
return 0;
}
}
{
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
+ debug_msg(RELEASE, "frame count: %d, dur: %d, num: %d, den: %d\n", frame_cnt, duration, r_frame_rate.num, r_frame_rate.den);
if (duration <= 0 || r_frame_rate.num <= 0 || r_frame_rate.den <= 0)
return 0;
#ifdef __MMFILE_TEST_MODE__
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);
+ debug_msg(RELEASE, "--------- AV Packet -----------\n");
+ debug_msg(RELEASE, " pts: %lld\n", pkt->pts);
+ debug_msg(RELEASE, " dts: %lld\n", pkt->dts);
+ debug_msg(RELEASE, " data: %p\n", pkt->data);
+ debug_msg(RELEASE, " size: %d\n", pkt->size);
+ debug_msg(RELEASE, " 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(RELEASE, " 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" : "_");
+ debug_msg(RELEASE, " 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(RELEASE, " duration: %d\n", pkt->duration);
+ /*debug_msg(RELEASE, " destruct: %p\n", pkt->destruct);*/
+ /*debug_msg(RELEASE, " priv: %p\n", pkt->priv);*/
+ debug_msg(RELEASE, " pos: %lld\n", pkt->pos);
+ debug_msg(RELEASE, " convergence_duration: %lld\n", pkt->convergence_duration);
+ debug_msg(RELEASE, "-------------------------------\n");
}
#endif
tmp_frame = av_frame_alloc();
if (!first_frame || !tmp_frame) {
- debug_error("failed to alloc frame.\n");
+ debug_error(DEBUG, "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
+ debug_msg(RELEASE, "frame: 1. %p, 2. %p\n", first_frame, tmp_frame);
#ifdef __MMFILE_FFMPEG_V085__
pCodecCtx->skip_frame = AVDISCARD_BIDIR;
ret = av_read_frame(pFormatCtx, &pkt);
if (ret < 0) {
- debug_error("read failed. (maybe EOF or broken)\n");
+ debug_error(DEBUG, "read failed. (maybe EOF or broken)\n");
break;
} else {
if (avcodec_get_type(pFormatCtx->streams[pkt.stream_index]->codec->codec_id) == AVMEDIA_TYPE_VIDEO) {
if ((pkt.flags & PKT_FLAG_KEY) || (key_detected == 1))
#endif
{
+ debug_msg(RELEASE, "video frame: %d, %d, %d\n", retry, i, v);
#ifdef __MMFILE_TEST_MODE__
- debug_msg("video frame: %d, %d, %d\n", retry, i, v);
_dump_av_packet(&pkt);
#endif
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(DEBUG, "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
+ debug_msg(RELEASE, "key frame!\n");
#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);
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);
+ debug_msg(RELEASE, "Elapsed time = %lld\n", ti);
#endif
if (ret != 0) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("is good frame.\n");
-#endif
+ debug_msg(RELEASE, "is good frame.\n");
break;
} else {
/*reset video frame count & retry searching*/
-#ifdef __MMFILE_TEST_MODE__
- debug_warning("not good fame. retry scanning.\n");
-#endif
+ debug_warning(RELEASE, "not good fame. retry scanning.\n");
i = 0;
v = 0;
retry++;
if (retry > _RETRY_SEARCH_LIMIT) break;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("skip (not key frame).\n");
-#endif
+ debug_msg(RELEASE, "skip (not key frame).\n");
#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
+ debug_msg(RELEASE, "decode not completed.\n");
key_detected = 1;
}
}
/*free pkt after loop breaking*/
if (pkt.data) av_free_packet(&pkt);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("found: %d, retry: %d\n", found, retry);
-#endif
+ debug_msg(RELEASE, "found: %d, retry: %d\n", found, retry);
/*set decode frame to output*/
if (found > 0) {
if (tmp_frame) av_free(tmp_frame);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("out frame: %p\n", *pFrame);
-#endif
+ debug_msg(RELEASE, "out frame: %p\n", *pFrame);
#ifdef __MMFILE_FFMPEG_V085__
pCodecCtx->skip_frame = AVDISCARD_NONE;
ret = -1;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("id: %d, mimetype: %s\n", formatId, mimeType);
-#endif
+ debug_msg(RELEASE, "id: %d, mimetype: %s\n", formatId, mimeType);
return ret;
}
if (!handle || !filename || !handle->prot) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
splitedString = mmfile_strsplit(filename, ":");
if (splitedString == NULL) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
if (!splitedString[0] || !splitedString[1])
{
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
goto exception;
}
memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
if (!memHandle) {
- debug_error("error: mmfile_malloc memHandle\n");
+ debug_error(DEBUG, "error: mmfile_malloc memHandle\n");
goto exception;
}
if (!h || !h->priv_data || !buf) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_UTIL_FAIL;
}
memHandle = h->priv_data;
if (!memHandle->ptr) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "File Read is beyond the file Size\n");
return MMFILE_UTIL_FAIL;
}
static int mmf_mem_write(URLContext *h, const unsigned char *buf, int size)
{
if (!h || !h->priv_data || !buf) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_UTIL_FAIL;
}
- debug_error("NOTE PERMITTED\n");
+ debug_error(DEBUG, "NOTE PERMITTED\n");
return MMFILE_UTIL_FAIL;
}
if (!h || !h->priv_data) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_UTIL_FAIL;
}
/*check validation*/
if (tmp_offset < 0 && tmp_offset > memHandle->size) {
- debug_error("invalid file offset\n");
+ debug_error(DEBUG, "invalid file offset\n");
return MMFILE_UTIL_FAIL;
}
MMFmemIOHandle *memHandle = NULL;
if (!h || !h->priv_data) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_UTIL_FAIL;
}
break;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("id: %d, mimetype: %s\n", formatId, mimeType);
-#endif
+ debug_msg(RELEASE, "id: %d, mimetype: %s\n", formatId, mimeType);
return ret;
}
int ret = 0;
MMFileIOHandle *fp = NULL;
- debug_error("%s\n", urifilename);
+ debug_error(DEBUG, "%s\n", urifilename);
ret = mmfile_open(&fp, urifilename, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "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
+ debug_msg(RELEASE, "search index = [%d]\n", index);
+
switch (index) {
case MM_FILE_FORMAT_QT:
case MM_FILE_FORMAT_3GP:
case MM_FILE_FORMAT_JPG:
break;
default: {
- debug_error("error: invaild format enum[%d]\n", index);
+ debug_error(DEBUG, "error: invaild format enum[%d]\n", index);
break;
}
}
}
if (index == MM_FILE_FORMAT_NUM) {
- debug_error("Can't probe file type\n");
+ debug_error(DEBUG, "Can't probe file type\n");
}
*format = -1;
#else
if (av_find_stream_info(pFormatCtx) < 0) {
#endif
- debug_error("error : av_find_stream_info failed");
+ debug_error(DEBUG, "error : av_find_stream_info failed");
ret = MMFILE_FORMAT_FAIL;
goto exception; /* Couldn't find stream information */
}
}
if (videoStream == -1) {
- debug_error("error : videoStream == -1");
+ debug_error(DEBUG, "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;
if (pVideoCodecCtx == NULL) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "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) {
- debug_error("error : Unsupported codec");
+ debug_error(DEBUG, "error : Unsupported codec");
ret = MMFILE_FORMAT_FAIL;
goto exception; /* Codec not found */
}
#else
if (avcodec_open(pVideoCodecCtx, pVideoCodec) < 0) {
#endif
- debug_error("error : avcodec_open failed");
+ debug_error(DEBUG, "error : avcodec_open failed");
ret = MMFILE_FORMAT_FAIL;
goto exception;; /*Could not open codec */
}
/* Allocate video frame */
pFrame = av_frame_alloc();
if (pFrame == NULL) {
- debug_error("error: pFrame is NULL\n");
+ debug_error(DEBUG, "error: pFrame is NULL\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* Allocate an AVFrame structure */
pFrameRGB = av_frame_alloc();
if (pFrameRGB == NULL) {
- debug_error("error: pFrameRGB is NULL\n");
+ debug_error(DEBUG, "error: pFrameRGB is NULL\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
#endif
duration = duration * MILLION;
if ((duration <= 0) || (duration <= pos)) {
- debug_error("duration error duration[%f] pos[%f]", duration, pos);
+ debug_error(DEBUG, "duration error duration[%f] pos[%f]", duration, pos);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* 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
+ #ifdef __MMFILE_TEST_MODE__
+ debug_msg(RELEASE, "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(DEBUG, "Error while decoding frame");
} else if ((packet.flags & AV_PKT_FLAG_KEY) || (key_detected == 1)) {
key_detected = 0;
if (got_picture) {
if (pFrame->key_frame) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("find Video Stream+++++++Find key frame");
-#endif
+ debug_msg(RELEASE, "find Video Stream+++++++Find key frame");
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("find Video Stream+++++++ not key frame");
-#endif
+ debug_msg(RELEASE, "find Video Stream+++++++ not key frame");
}
/*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__
- debug_msg("find Video Stream+++++++Find key but no frame");
-#endif
+ debug_msg(RELEASE, "find Video Stream+++++++Find key but no frame");
key_detected = 1;
}
}
/* Did we get a video frame?*/
if (got_picture && find) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Find Frame");
-#endif
+ debug_msg(RELEASE, "Find Frame");
+
/* return frame infromations*/
if ((pVideoCodecCtx->width == 0) || (pVideoCodecCtx->height == 0)) {
*width = pVideoCodecCtx->coded_width;
*frame = mmfile_malloc(*size);
if (NULL == *frame) {
- debug_error("error: avpicture_get_size. [%d]\n", size);
+ debug_error(DEBUG, "error: avpicture_get_size. [%d]\n", size);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("size : %d", *size);
- debug_msg("width : %d", *width);
- debug_msg("height : %d", *height);
- debug_msg("frame : %x", *frame);
-#endif
+ debug_msg(RELEASE, "size : %d", *size);
+ debug_msg(RELEASE, "width : %d", *width);
+ debug_msg(RELEASE, "height : %d", *height);
+ debug_msg(RELEASE, "frame : %x", *frame);
+
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(DEBUG, "error: avpicture_fill fail. errcode = 0x%08X\n", ret);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
*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(DEBUG, "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");
+ debug_error(DEBUG, "failed to convet image\n");
sws_freeContext(img_convert_ctx);
img_convert_ctx = NULL;
ret = MMFILE_FORMAT_FAIL;
#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");
+ debug_error(DEBUG, "failed to convet image\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
__save_frame(pFrameRGB, pVideoCodecCtx->width, pVideoCodecCtx->height, (int)(pos / 1000));
#endif
} else {
- debug_error("Not Found Proper Frame[%d][%d]", got_picture, find);
+ debug_error(DEBUG, "Not Found Proper Frame[%d][%d]", got_picture, find);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/* Open video file */
if (avformat_open_input(&pFormatCtx, path, NULL, NULL) != 0) {
- debug_error("error : avformat_open_input failed");
+ debug_error(DEBUG, "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(DEBUG, "failed to find av stream. maybe corrupted data.\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
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(DEBUG, "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(DEBUG, "error: file format is invalid\n");
return MMFILE_FORMAT_FAIL;
}
#endif
if (__getMimeType(format, mimeType, MMFILE_MIMETYPE_MAX_LEN) < 0) {
- debug_error("error: Error in MIME Type finding\n");
+ debug_error(DEBUG, "error: Error in MIME Type finding\n");
return MMFILE_FORMAT_FAIL;
}
ret = mmfile_util_get_ffmpeg_format(mimeType, ffmpegFormatName);
if (MMFILE_UTIL_SUCCESS != ret) {
- debug_error("error: mmfile_util_get_ffmpeg_format\n");
+ debug_error(DEBUG, "error: mmfile_util_get_ffmpeg_format\n");
return MMFILE_FORMAT_FAIL;
}
grab_iformat = av_find_input_format(ffmpegFormatName);
if (NULL == grab_iformat) {
- debug_error("error: cannot find format\n");
+ debug_error(DEBUG, "error: cannot find format\n");
goto exception;
}
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);
+ debug_error(DEBUG, "error: cannot open %s %d\n", urifilename, ret);
goto exception;
}
if (!pFormatCtx) {
- debug_warning("failed to find av stream. maybe corrupted data.\n");
+ debug_warning(DEBUG, "failed to find av stream. maybe corrupted data.\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
int ret = 0;
if (!formatContext) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
ret = MMFileFormatIsValidIMY(NULL, formatContext->uriFileName);
if (ret == 0) {
- debug_error("It is not imelody file\n");
+ debug_error(DEBUG, "It is not imelody file\n");
return MMFILE_FORMAT_FAIL;
}
}
int ret = 0;
if (!formatContext) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
/*convert iMelody to Midi*/
imy = __get_load_memory(formatContext->uriFileName, &imy_size);
if (!imy) {
- debug_error("failed to load memory.\n");
+ debug_error(DEBUG, "failed to load memory.\n");
goto exception;
}
ret = __is_good_imelody(imy, imy_size);
if (ret != MMFILE_FORMAT_SUCCESS) {
- debug_error("it's broken file.\n");
+ debug_error(DEBUG, "it's broken file.\n");
goto exception;
}
midi = __AvConvertIMelody2MIDI((char *)imy, &midi_size);
if (!midi) {
- debug_error("failed to convert.");
+ debug_error(DEBUG, "failed to convert.");
goto exception;
}
/*get infomation*/
info = mmfile_format_get_midi_infomation(src2);
if (!info) {
- debug_error("failed to get infomation");
+ debug_error(DEBUG, "failed to get infomation");
goto exception;
}
audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error("error: mmfile_malloc audiostream\n");
+ debug_error(DEBUG, "error: mmfile_malloc audiostream\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
const char *locale = MMFileUtilGetLocale(NULL);
if (!formatContext) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
(unsigned int *)&cnv_len);
if (formatContext->title == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->title = mmfile_strdup(taginfo.title);
}
mmfile_free(taginfo.title);
NULL,
(unsigned int *)&cnv_len);
if (formatContext->composer == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->composer = mmfile_strdup(taginfo.composer);
}
mmfile_free(taginfo.composer);
NULL,
(unsigned int *)&cnv_len);
if (formatContext->comment == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->comment = mmfile_strdup(taginfo.comment);
}
mmfile_free(taginfo.comment);
NULL,
(unsigned int *)&cnv_len);
if (formatContext->copyright == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->copyright = mmfile_strdup(taginfo.copyright);
}
mmfile_free(taginfo.copyright);
int ret = MMFILE_FORMAT_FAIL;
if (!uriname || !tags) {
- debug_error("uriname or tags is NULL\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "open failed.\n");
return MMFILE_FORMAT_FAIL;
}
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_IMY_HEADER_LENGTH) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
ret = MMFILE_FORMAT_FAIL;
goto exit;
}
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);
+ debug_error(DEBUG, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
break;
}
/*open*/
ret = mmfile_open(&fp, src, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("open failed.\n");
+ debug_error(DEBUG, "open failed.\n");
return NULL;
}
mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (src_size <= 0) {
- debug_error("failed to get file size.\n");
+ debug_error(DEBUG, "failed to get file size.\n");
goto failed;
}
/*alloc read buffer*/
if ((buf = mmfile_malloc(src_size)) == NULL) {
- debug_error("memory allocation failed.\n");
+ debug_error(DEBUG, "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);
+ debug_error(DEBUG, "read error. size = %d\n", readed);
goto failed;
}
*/
while (!((*pMelodyBuf == 'E' && *(pMelodyBuf + 2) == 'D') || (*pMelodyBuf == '\n'))) {
if (noteCount >= AV_MIDI_NOTE_MAX) {
- debug_warning("__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
+ debug_warning(DEBUG, "__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
break;
}
while (*pMelodyBuf != 'E') {
if (noteCount >= AV_MIDI_NOTE_MAX) {
- debug_warning("__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
+ debug_warning(DEBUG, "__AvConvertIMelody2MIDI : noteCount>=AV_MIDI_NOTE_MAX\n");
break;
}
pConvertBuf = (unsigned char *) mmfile_malloc(*pBufLen);
if (pConvertBuf == NULL) {
- debug_error("__AvConvertIMelody2MIDI: malloc failed!\n");
+ debug_error(DEBUG, "__AvConvertIMelody2MIDI: malloc failed!\n");
return NULL;
}
beatValue = 1000000 * 60 / bpmValue[3];
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("beat: %d = 1000000 * 60 / %d\n", beatValue, bpmValue[3]);
-#endif
+ debug_msg(RELEASE, "beat: %d = 1000000 * 60 / %d\n", beatValue, bpmValue[3]);
return beatValue;
}
}
if (styleValue < '0' || styleValue > '2') {
- debug_warning("unknown style. use default(S0)\n");
+ debug_warning(DEBUG, "unknown style. use default(S0)\n");
styleValue = '0';
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("style: '%c'\n", styleValue);
-#endif
+ debug_msg(RELEASE, "style: '%c'\n", styleValue);
return styleValue;
}
int res = MMFILE_FORMAT_FAIL;
if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error("error: mmfile_format_open_mid\n");
+ debug_error(DEBUG, "error: mmfile_format_open_mid\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
res = MMFileFormatIsValidMID(NULL, formatContext->uriFileName);
if (res == 0) {
- debug_error("It is not MIDI file\n");
+ debug_error(DEBUG, "It is not MIDI file\n");
return MMFILE_FORMAT_FAIL;
}
}
MIDI_INFO_SIMPLE *info = NULL;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/*get infomation*/
info = mmfile_format_get_midi_infomation(formatContext->uriFileName);
if (!info) {
- debug_error("failed to get infomation");
+ debug_error(DEBUG, "failed to get infomation");
goto exception;
}
audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
if (NULL == audioStream) {
- debug_error("error: mmfile_malloc audiostream\n");
+ debug_error(DEBUG, "error: mmfile_malloc audiostream\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
unsigned int cnv_len;
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
/*get infomation*/
info = mmfile_format_get_midi_infomation(formatContext->uriFileName);
if (!info) {
- debug_error("failed to get infomation");
+ debug_error(DEBUG, "failed to get infomation");
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
NULL,
(unsigned int *)&cnv_len);
if (formatContext->title == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->title = mmfile_strdup(info->title);
}
}
NULL,
(unsigned int *)&cnv_len);
if (formatContext->copyright == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->copyright = mmfile_strdup(info->copyright);
}
}
NULL,
(unsigned int *)&cnv_len);
if (formatContext->comment == NULL) {
- debug_warning("failed to UTF8 convert.\n");
+ debug_warning(DEBUG, "failed to UTF8 convert.\n");
formatContext->comment = mmfile_strdup(info->comment);
}
}
EXPORT_API
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(DEBUG, "error: mmfile_format_read_frame_midi, no handling\n");
return MMFILE_FORMAT_FAIL;
}
int mmfile_format_close_mid(MMFileFormatContext *formatContext)
{
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
if (szFileName == NULL || info == NULL)
return -1;
- /* debug_msg("URI: %s\n", szFileName); */
+ /* debug_msg(DEBUG, "URI: %s\n", szFileName); */
/*open*/
ret = mmfile_open(&hFile, szFileName, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("open failed.\n");
+ debug_error(DEBUG, "open failed.\n");
return -1;
}
mmfile_seek(hFile, 0L, MMFILE_SEEK_SET);
if (dFileSize <= 0) {
- debug_error("failed to get file size.\n");
+ debug_error(DEBUG, "failed to get file size.\n");
goto _RELEASE_RESOURCE;
}
/*alloc read buffer*/
pbFile = (UINT8 *) mmfile_malloc(sizeof(UINT8) * (dFileSize + 1));
if (!pbFile) {
- debug_error("memory allocation failed.\n");
+ debug_error(DEBUG, "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);
+ debug_error(DEBUG, "read error. size = %d\n", readed);
goto _RELEASE_RESOURCE;
}
}
if (sdCurrentTime < 0) {
- debug_error("__AvGetMidiDuration: sdResult's error Code!(%d)\n", sdCurrentTime);
+ debug_error(DEBUG, "__AvGetMidiDuration: sdResult's error Code!(%d)\n", sdCurrentTime);
goto _RELEASE_RESOURCE;
}
dTemp = (UINT32)pMt->pbBase[pMt->dOffset++];
dTime = (dTime << 7) + (dTemp & 0x7f);
} while (dTemp >= 0x80);
- /*debug_msg("dTime is %d\n", dTime); */
+ /*debug_msg(DEBUG, "dTime is %d\n", dTime); */
pMt->sdTicks += dTime;
return (0);
__AvMidInitializeOrderList(pI);
if ((UINT32)pI->dNumOfTracks > MAX_SMF_TRACKS) {
- debug_error("__AvMidResetTimeInfo: Num of tracks is over MAX track number. !!\n");
+ debug_error(DEBUG, "__AvMidResetTimeInfo: Num of tracks is over MAX track number. !!\n");
return;
}
}
if ((UINT32)sdTr >= MAX_SMF_TRACKS) {
- debug_error("__AvGetSizeOfFileInfo: Num of tracks is over MAX track number. !!\n");
+ debug_error(DEBUG, "__AvGetSizeOfFileInfo: Num of tracks is over MAX track number. !!\n");
return AvSMW_ERROR_SMF_CMD;
}
__AvMidUpdateTrackTime(pI, (UINT32)sdTr);
}
if ((pI->sdDataEndTime >> 10) <= MINIMUM_LENGTH) return (AvSMW_ERROR_SHORT_LENGTH);
- /* debug_msg("__AvGetSizeOfFileInfo/Done\n"); */
+ /* debug_msg(DEBUG, "__AvGetSizeOfFileInfo/Done\n"); */
return pI->sdDataEndTime;
}
UINT32 dNumOfTracks;
UINT32 i;
UINT8 *fp = src_fp;
- /* debug_msg("input param: %p, %d\n", fp, dFsize); */
+ /* debug_msg(DEBUG, "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];
dFsize--;
}
- /* debug_msg("__AvCheckSizeOfMidFile(): MThd Position is dFsize(%d)\n", dFsize); */
+ /* debug_msg(DEBUG, "__AvCheckSizeOfMidFile(): MThd Position is dFsize(%d)\n", dFsize); */
if (dFsize < 22) {
- debug_error("__AvCheckSizeOfMidFile Error / Too small size\n");
+ debug_error(DEBUG, "__AvCheckSizeOfMidFile Error / Too small size\n");
return (AvSMW_ERROR_FILE);
}
((UINT32)fp[2] << 8) + (UINT32)fp[3];
if (dTemp != 6) {
- debug_error("__AvCheckSizeOfMidFile Error / Size != 6\n");
+ debug_error(DEBUG, "__AvCheckSizeOfMidFile Error / Size != 6\n");
return (AvSMW_ERROR_CHUNK_SIZE);
}
/*--- Check format -------------------------------------------------*/
dFormat = ((UINT32)fp[0] << 8) + (UINT32)fp[1];
if (dFormat > 1) {
- debug_error("__AvCheckSizeOfMidFile Error/ Not Format 0 or 1\n");
+ debug_error(DEBUG, "__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");
+ debug_error(DEBUG, "__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");
+ debug_error(DEBUG, "__AvCheckSizeOfMidFile Error/ Number of Tracks > 1\n");
return (AvSMW_ERROR_SMF_TRACKNUM);
}
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");
+ debug_error(DEBUG, "__AvCheckSizeOfMidFile Error/ Unknown TimeUnit\n");
return (AvSMW_ERROR_SMF_TIMEUNIT);
}
fp += 6;
}
if (dFsize < 8) {
- debug_error("__AvCheckSizeOfMidFile Error/ Bad size\n");
+ debug_error(DEBUG, "__AvCheckSizeOfMidFile Error/ Bad size\n");
return (AvSMW_ERROR_CHUNK_SIZE);
}
((UINT32)fp[6] << 8) + (UINT32)fp[7];
if (dFsize < (dSize + 8)) {
- debug_error("__AvCheckSizeOfMidFile Error/ Bad size [%ld] vs [%ld]\n", dFsize, dSize + 22);
+ debug_error(DEBUG, "__AvCheckSizeOfMidFile Error/ Bad size [%ld] vs [%ld]\n", dFsize, dSize + 22);
return (AvSMW_ERROR_CHUNK_SIZE);
}
pI->TrackInfo[i].pbBase = &fp[8];
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
+ debug_msg(RELEASE, "__AvParseSkipForXMF : MThd Header found!\n");
break;
} else {
skipVal++;
if (skipVal >= sizeOfpbFile) {
- debug_error("__AvParseSkipForXMF : MThd Header is not found!\n");
- debug_error("__AvParseSkipForXMF :skipVal(%d) sizeOfpbFile(%d) \n", skipVal, sizeOfpbFile);
+ debug_error(DEBUG, "__AvParseSkipForXMF : MThd Header is not found!\n");
+ debug_error(DEBUG, "__AvParseSkipForXMF :skipVal(%d) sizeOfpbFile(%d) \n", skipVal, sizeOfpbFile);
return -1;
}
}
}
- /* debug_msg("__AvParseSkipForXMF : skip value(%d)\n", skipVal); */
+ /* debug_msg(DEBUG, "__AvParseSkipForXMF : skip value(%d)\n", skipVal); */
return skipVal;
}
int ret = 0;
if (NULL == formatContext) {
- debug_error("error: formatContext is NULL\n");
+ debug_error(DEBUG, "error: formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
ret = MMFileFormatIsValidMMF(NULL, formatContext->uriFileName);
if (ret == 0) {
- debug_error("error: it is not MMF file\n");
+ debug_error(DEBUG, "error: it is not MMF file\n");
return MMFILE_FORMAT_FAIL;
}
}
total = mmf_file_mmf_get_duration(formatContext->uriFileName, 0 /*not XMF*/);
if (total < 0) {
- debug_error("error: get duration\n");
+ debug_error(DEBUG, "error: get duration\n");
return MMFILE_FORMAT_FAIL;
}
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");
+ debug_error(DEBUG, "error: mmfile_malloc, audido stream\n");
return MMFILE_FORMAT_FAIL;
}
/* 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
+ debug_msg(RELEASE, "Play time: %ld\n", psTrack->dPlayTime);
return AV_MMF_FUNC_SUCCESS;
}
}
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Play time: %ld\n", psLoad->dPlayTime);
-#endif
+ debug_msg(RELEASE, "Play time: %ld\n", psLoad->dPlayTime);
return AV_MMF_FUNC_SUCCESS;
}
/* 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
+ debug_msg(RELEASE, "Play time: %ld\n", psTrk->dPlayTime);
return AV_MMF_FUNC_SUCCESS;
}
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Play time: %ld\n", psLoad->dPlayTime);
-#endif
+ debug_msg(RELEASE, "Play time: %ld\n", psLoad->dPlayTime);
return AV_MMF_FUNC_SUCCESS;
}
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Play time: %ld\n", psLoad->dPlayTime);
-#endif
+ debug_msg(RELEASE, "Play time: %ld\n", psLoad->dPlayTime);
return AV_MMF_FUNC_SUCCESS;
}
/* 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
+ debug_msg(RELEASE, "SUM %ld\n", psLoad_Info->dPlayTime * psLoad_Info->dTimeBase);
if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) <= AV_MMF_PLAY_TIME_MIN) {
return AV_MMF_ERR_SLENGTH;
if (pbFile)
memcpy(cmpXmfCMMD, pbFile, 4);
else {
- debug_error("NULL pointer!\n");
+ debug_error(DEBUG, "NULL pointer!\n");
return -1;
}
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
+ debug_msg(RELEASE, "MMMD Header found!\n");
break;
} else {
skipVal++;
if (skipVal >= sizeOfpbFile) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MMMD Header is not found!\n");
-#endif
+ debug_msg(RELEASE, "MMMD Header is not found!\n");
return -1;
}
}
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("File header is not started CMMD\n");
-#endif
+ debug_msg(RELEASE, "File header is not started CMMD\n");
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("skip value: %d\n", skipVal);
-#endif
+ debug_msg(RELEASE, "skip value: %d\n", skipVal);
return skipVal;
}
/*total time (millisecond)*/
int ret_msec = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
/*open*/
ret = mmfile_open(&fp, src, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("open failed.\n");
+ debug_error(DEBUG, "open failed.\n");
return -1;
}
mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (src_size <= 0) {
- debug_error("failed to get file size.\n");
+ debug_error(DEBUG, "failed to get file size.\n");
ret_msec = -1;
goto _RELEASE_RESOURCE;
}
/*alloc work buffer*/
buf = mmfile_malloc(src_size + 1);
if (!buf) {
- debug_error("failed to memory allocaion.\n");
+ debug_error(DEBUG, "failed to memory allocaion.\n");
ret_msec = -1;
goto _RELEASE_RESOURCE;
}
/*read data*/
if ((readed = mmfile_read(fp, buf, src_size)) <= 0) {
- debug_error("read error. size = %d\n", readed);
+ debug_error(DEBUG, "read error. size = %d\n", readed);
ret_msec = -1;
goto _RELEASE_RESOURCE;
AvFileContentInfo *privateData = NULL;;
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if (NULL == formatContext) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
ret = MMFileFormatIsValidMP3(NULL, formatContext->uriFileName, 5);
if (ret == 0) {
- debug_error("It is not mp3 file\n");
+ debug_error(DEBUG, "It is not mp3 file\n");
return MMFILE_FORMAT_FAIL;
}
}
privateData = mmfile_malloc(sizeof(AvFileContentInfo));
if (!privateData) {
- debug_error("error: mmfile_malloc MP3 privateData\n");
+ debug_error(DEBUG, "error: mmfile_malloc MP3 privateData\n");
return MMFILE_FORMAT_FAIL;
}
ret = mmf_file_mp3_get_infomation(formatContext->uriFileName, privateData);
if (ret == -1) {
- debug_error("error: mmfile_format_read_stream_mp3\n");
+ debug_error(DEBUG, "error: mmfile_format_read_stream_mp3\n");
goto exception;
}
{
AvFileContentInfo *privateData = NULL;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if (!formatContext || !formatContext->privateFormatData) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
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");
+ debug_error(DEBUG, "formatContext->streams[MMFILE_AUDIO_STREAM] is NULL\n");
return MMFILE_FORMAT_FAIL;
}
{
AvFileContentInfo *privateData = NULL;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if (!formatContext || !formatContext->privateFormatData) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
if (strlen(privateData->imageInfo.imageMIMEType) > 0)
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
+ debug_msg(RELEASE, "ID3 tag V2 File");
formatContext->artworkMime = mmfile_strdup(privateData->imageInfo.imageExt);
} else {
- debug_error("Album art image exist but there is no type information of album art\n");
+ debug_error(DEBUG, "Album art image exist but there is no type information of album art\n");
}
}
}
headData->vbrScale = __AvExtractI4(buf);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Xing header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
+ debug_msg(RELEASE, "Xing header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
headData->sampRate, headData->bytes, headData->frames);
-#endif
return 1; /* success */
}
buf += 2;
headData->framesPerTable = __AvExtractI2(buf);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Vbri header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
+ debug_msg(RELEASE, "Vbri header: sampling-rate:%d, stream-size:%d, frame-number:%d\n",
headData->sampRate, headData->bytes, headData->frames);
-#endif
return true; /* success */
}
mp3FrameDataValid[3] = (buf[AV_MP3HDR_CHANNEL_OFS] & AV_MP3HDR_CHANNEL_M) &
(mp3FrameMasking[3]);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("*** [%02x][%02x][%02x][%02x] : [%02x][%02x][%02x][%02x]",
+ debug_msg(RELEASE, "*** [%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
(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
+ debug_msg(RELEASE, "=> %s\n", bSync ? "Good!" : "Bad...");
}
if (bSync == true)
{
unsigned char result;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("### [%02x][%02x][%02x][%02x] ###\n", header[0], header[1], header[2], header[3]);
-#endif
+ debug_msg(RELEASE, "### [%02x][%02x][%02x][%02x] ###\n", header[0], header[1], header[2], header[3]);
/* 1. Check the version of mp3 */
result = header[1] & MASK_MPEG;
else
pInfo->bPadding = false;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("=> samplerate=%d, bitrate=%d, layer=%d, version=%d, channel=%d, padding=%d",
+ debug_msg(RELEASE, "=> 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;
}
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(DEBUG, "invalid Xing header\n");
return false;
}
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(DEBUG, "invalid Vbri header\n");
return false;
}
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(DEBUG, "read error occured.\n");
return 0;
}
if (memcmp(tagHeader, "ID3", 3) == 0) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("'ID3' found.\n");
-#endif
+ debug_msg(RELEASE, "'ID3' found.\n");
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("'ID3' not found.\n");
-#endif
+ debug_msg(RELEASE, "'ID3' not found.\n");
goto search_end;
}
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
+ debug_msg(RELEASE, "good ID3V2 tag.\n");
} else {
- debug_warning("It's bad ID3V2 tag.\n");
+ debug_warning(DEBUG, "It's bad ID3V2 tag.\n");
goto search_end;
}
tagVersion = tagHeader[3];
if (tagVersion > 4) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Tag version not supported\n");
-#endif
+ debug_msg(RELEASE, "Tag version not supported\n");
goto search_end;
}
/**@note unfortunately, some contents has many id3 tag.*/
acc_tagsize += tagInfoSize;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
-#endif
+ debug_msg(RELEASE, "tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
mmfile_seek(fp, acc_tagsize, MMFILE_SEEK_SET);
*offset = acc_tagsize;
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
+ debug_msg(RELEASE, "pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagVersion);
}
id3v2TagLen = pInfo->tagV2Info.tagLen;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("id3v2TagLen(%d)\n", id3v2TagLen);
-#endif
+ debug_msg(RELEASE, "id3v2TagLen(%d)\n", id3v2TagLen);
if (id3v2TagLen) {
if (mmfile_seek(hFile, id3v2TagLen, SEEK_SET) < 0) {
- debug_error("seek failed.\n");
+ debug_error(DEBUG, "seek failed.\n");
return -1;
}
if ((readLen = mmfile_read(hFile, buf, bufLen)) <= 0) {
- debug_error("seek failed.\n");
+ debug_error(DEBUG, "seek failed.\n");
return -1;
}
}
if (bufLen - index > 256) {
pHeader = mmfile_malloc(256);
if (pHeader == NULL) {
- debug_error("malloc failed.\n");
+ debug_error(DEBUG, "malloc failed.\n");
return -1;
}
strncpy((char *)pHeader, (char *)buf, 256);
} else {
- debug_error("Header field is not exist\n");
+ debug_error(DEBUG, "Header field is not exist\n");
return -1;
}
if (__AvParseMp3Header(pInfo, pHeader) == false) {
/*return -1; */
if (pHeader)
_FREE_EX(pHeader);
- debug_warning("Mp3 parse header failed & index(%d)\n", index);
+ debug_warning(DEBUG, "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
+ debug_msg(RELEASE, "This header is valid. index(%d)\n", index);
}
if (__AvParseXingHeader(pInfo, pHeader)) {
pInfo->datafileLen = pInfo->fileLen - pInfo->headerPos;
frameLen = pInfo->frameSize;
if (frameLen) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("<<< frameLen=[%d] >>> \n", frameLen);
-#endif
+ debug_msg(RELEASE, "<<< frameLen=[%d] >>> \n", frameLen);
#ifndef __MMFILE_NEW_FRAME_FUNC /* FIXME : what purpose to do this? */
/* Account for loss of precision in the frame length calculation*/
}
} else {
- debug_warning("Is not vaild header pHeader\n");
+ debug_warning(DEBUG, "Is not vaild header pHeader\n");
}
}
if (pHeader)
_FREE_EX(pHeader);
} else {
- debug_warning("Mp3 file frist byte is 0xff, but not header sync\n");
+ debug_warning(RELEASE, "Mp3 file frist byte is 0xff, but not header sync\n");
}
}
buf++;
_FREE_EX(pHeader);
if (mmfile_seek(hFile, 0, SEEK_SET) < 0) {
- debug_error("seek error!\n");
+ debug_error(DEBUG, "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);
+ debug_warning(DEBUG, "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
+ debug_msg(RELEASE, "Mp3 file found a sync Success!\n");
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Mp3 file found a sync Failed!\n");
-#endif
+ debug_msg(RELEASE, "Mp3 file found a sync Failed!\n");
return -1;
}
int ret = 0;
unsigned int head_offset = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if (pInfo == NULL || filename == NULL)
return -1;
/*open*/
ret = mmfile_open(&hFile, filename, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("open failed.\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "file is too small.\n");
goto EXCEPTION;
}
mmfile_seek(hFile, 0L, SEEK_SET);
v2TagExistCheck = mmfile_malloc(MP3_TAGv2_HEADER_LEN);
if (v2TagExistCheck == NULL) {
- debug_error("malloc failed.\n");
+ debug_error(DEBUG, "malloc failed.\n");
goto EXCEPTION;
}
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
+ debug_msg(RELEASE, "pInfo->tagV2Info.tagLen(%d), pInfo->tagV2Info.tagVersion(%d)\n", pInfo->tagV2Info.tagLen, pInfo->tagV2Info.tagVersion);
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tag is a not supported version(%d)\n", v2TagExistCheck[3]);
-#endif
+ debug_msg(RELEASE, "tag is a not supported version(%d)\n", v2TagExistCheck[3]);
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tag is a tag data is valid.\n");
-#endif
+ debug_msg(RELEASE, "tag is a tag data is valid.\n");
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("this mp3 file is not included ID3v2 tag info!\n");
-#endif
+ debug_msg(RELEASE, "this mp3 file is not included ID3v2 tag info!\n");
}
} else {
- debug_error("v2TagExistCheck value read fail!\n");
+ debug_error(DEBUG, "v2TagExistCheck value read fail!\n");
if (v2TagExistCheck)
_FREE_EX(v2TagExistCheck);
goto EXCEPTION;
if (mmfile_seek(hFile, 0L, SEEK_SET) < 0)
goto EXCEPTION;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->fileLen(%lld)\n", pInfo->fileLen);
-#endif
+ debug_msg(RELEASE, "pInfo->fileLen(%lld)\n", pInfo->fileLen);
if (pInfo->fileLen > ((long long)_AV_MP3_HEADER_POSITION_MAX + (long long)pInfo->tagV2Info.tagLen)) {
readAmount = _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen;
buf = mmfile_malloc(readAmount);
if (buf == NULL) {
- debug_error("malloc failed.\n");
+ debug_error(DEBUG, "malloc failed.\n");
goto EXCEPTION;
}
goto EXCEPTION;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Reading buf readedDataLen(%d) readAmount (%d)\n", readedDataLen, readAmount);
-#endif
+ debug_msg(RELEASE, "Reading buf readedDataLen(%d) readAmount (%d)\n", readedDataLen, readAmount);
}
} else {
if ((readedDataLen <= _AV_MP3_HEADER_POSITION_MAX + pInfo->tagV2Info.tagLen)
goto EXCEPTION;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("The remained buf readed! readedDataLen(%d) readAmount (%d)\n", readedDataLen, readAmount);
-#endif
+ debug_msg(RELEASE, "The remained buf readed! readedDataLen(%d) readAmount (%d)\n", readedDataLen, readAmount);
}
}
if (__AvGetLastID3offset(hFile, &head_offset)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("search start offset: %u\n", head_offset);
-#endif
+ debug_msg(RELEASE, "search start offset: %u\n", head_offset);
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
+ debug_msg(RELEASE, "Header Pos: %ld\n", pInfo->headerPos);
if (buf)
_FREE_EX(buf);
} 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
+ debug_msg(RELEASE, "Mp3 File FrameSize (%d) pInfo->headerPos(%d)\n", pInfo->frameSize, pInfo->headerPos);
}
if (mmfile_seek(hFile, -(MP3TAGINFO_SIZE + TAGV1_SEEK_GAP), SEEK_END) < 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
+ debug_msg(RELEASE, "Mp3 File Tag is existing\n");
pInfo->bV1tagFound = true;
/* In this case, V2 Tag not exist.. So, try to read V1 tag */
frameSamples = MPEG_2_SIZE_LAYER_2_3;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("frameSamples : %d, tempduration : %ld", frameSamples, tempduration);
-#endif
+ debug_msg(RELEASE, "frameSamples : %d, tempduration : %ld", frameSamples, tempduration);
if (tempduration < (unsigned long long)pInfo->sampleRate) {
tempduration = (tempduration * frameSamples * 10) / pInfo->sampleRate;
#else
if (pInfo->bVbr) {
pInfo->duration = ((double)(frameSamples * 1000) / pInfo->sampleRate) * pInfo->frameNum;
- debug_msg("duration for VBR : %lld", pInfo->duration);
+ debug_msg(DEBUG, "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); */
- debug_msg("duration from new algorithm : %lld", pInfo->duration);
+ debug_msg(DEBUG, "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
+ debug_msg(RELEASE, "Mp3 File pInfo->duration (%lld) \n", pInfo->duration);
+ debug_msg(RELEASE, "** MP3 **\n");
+ debug_msg(RELEASE, "Version : %u\n", pInfo->mpegVersion);
+ debug_msg(RELEASE, "Layer : %u\n", pInfo->layer);
+ debug_msg(RELEASE, "Channel idx: %u\n", pInfo->channelIndex);
+ debug_msg(RELEASE, "Is VBR : %d\n", (pInfo->bVbr == true ? 1 : 0));
+ debug_msg(RELEASE, "Bitrate : %u\n", pInfo->bitRate);
+ debug_msg(RELEASE, "SampleRate : %u\n", pInfo->sampleRate);
+ debug_msg(RELEASE, "Channels : %u\n", pInfo->channels);
+ debug_msg(RELEASE, "**** Info #1 ****\n");
+ debug_msg(RELEASE, "Title : %s\n", pInfo->pTitle);
+ debug_msg(RELEASE, "Artist : %s\n", pInfo->pArtist);
+ debug_msg(RELEASE, "Album : %s\n", pInfo->pAlbum);
+ debug_msg(RELEASE, "Album_Artist: %s\n", pInfo->pAlbum_Artist);
+ debug_msg(RELEASE, "Year : %s\n", pInfo->pYear);
+ debug_msg(RELEASE, "Comment : %s\n", pInfo->pComment);
+ debug_msg(RELEASE, "TrackNum : %s\n", pInfo->pTrackNum);
+ debug_msg(RELEASE, "Genre : %s\n", pInfo->pGenre);
+ debug_msg(RELEASE, "**** Info #2 ****\n");
+ debug_msg(RELEASE, "Author : %s\n", pInfo->pAuthor);
+ debug_msg(RELEASE, "Copyright : %s\n", pInfo->pCopyright);
+ debug_msg(RELEASE, "Comment : %s\n", pInfo->pComment);
+ debug_msg(RELEASE, "Rating : %s\n", pInfo->pRating);
+ debug_msg(RELEASE, "RecDate : %s\n", pInfo->pRecDate);
+ debug_msg(RELEASE, "Encoded by : %s\n", pInfo->pEncBy);
+ debug_msg(RELEASE, "URL : %s\n", pInfo->pURL);
+ debug_msg(RELEASE, "Ori. Artist : %s\n", pInfo->pOriginArtist);
+ debug_msg(RELEASE, "Composer : %s\n", pInfo->pComposer);
+ debug_msg(RELEASE, "Conductor : %s\n", pInfo->pConductor);
+ debug_msg(RELEASE, "Artwork : mime(%s) addr(%p) size(%d)\n", pInfo->imageInfo.imageMIMEType, pInfo->imageInfo.pImageBuf, pInfo->imageInfo.imageLen);
+ debug_msg(RELEASE, "UnsyncLyrics : %s\n", pInfo->pUnsyncLyrics);
+ debug_msg(RELEASE, "SyncLyrics size : %d\n", pInfo->syncLyricsNum);
return 0;
EXCEPTION:
- debug_error("Error occured!\n");
+ debug_error(DEBUG, "Error occured!\n");
mmfile_close(hFile);
return -1;
}
int ret = 0;
if (!fp || !out) {
- debug_error("Invalid input\n");
+ debug_error(DEBUG, "Invalid input\n");
return MMFILE_ID3TAG_FAIL;
}
ret = mmfile_read(fp, tagSymbol, 3);
if (MMFILE_UTIL_FAIL == ret) {
- debug_error("read error\n");
+ debug_error(DEBUG, "read error\n");
return MMFILE_ID3TAG_FAIL;
}
ret = mmfile_read(fp, versionBuf, 2);
if (MMFILE_UTIL_FAIL == ret) {
- debug_error("read error\n");
+ debug_error(DEBUG, "read error\n");
return MMFILE_ID3TAG_FAIL;
}
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
+ debug_msg(RELEASE, "typeOfTag = %d\n", out->typeOfTag);
+ debug_msg(RELEASE, "startOffset = %d\n", out->startOffset);
+ debug_msg(RELEASE, "endOffset = %d\n", out->endOffset);
+ debug_msg(RELEASE, "bAppendedTag = %d\n", out->bAppendedTag);
+ debug_msg(RELEASE, "tagSize = %d\n", out->tagSize);
+ debug_msg(RELEASE, "version = %d\n", out->version);
return MMFILE_ID3TAG_SUCCESS;
}
int ret = 0;
if (!fp || !out) {
- debug_error("Invalid input\n");
+ debug_error(DEBUG, "Invalid input\n");
return MMFILE_ID3TAG_FAIL;
}
ret = mmfile_read(fp, header, MMFILE_ID3V2TAG_HEADER_SIZE);
if (MMFILE_UTIL_FAIL == ret) {
- debug_error("read error\n");
+ debug_error(DEBUG, "read error\n");
return MMFILE_ID3TAG_FAIL;
}
out->version = MMFILE_ID3TAG_V2_4;
break;
default:
- debug_warning("unknown version of id3v2\n");
+ debug_warning(DEBUG, "unknown version of id3v2\n");
break;
}
privateData = mmfile_malloc(sizeof(tMMFileTagsData));
if (!privateData) {
- debug_error("mmfile_malloc: tMMFileTagsData\n");
+ debug_error(DEBUG, "mmfile_malloc: tMMFileTagsData\n");
return MMFILE_TAGS_FAIL;
}
ret = mmfile_open(&privateData->fp, uriName, MMFILE_RDONLY);
if (MMFILE_UTIL_FAIL == ret) {
- debug_error("mmfile_open\n");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "mmfile_seek\n");
ret = MMFILE_TAGS_FAIL;
goto exception;
}
while (MMFILE_TAGS_SUCCESS == _MMFileFindAppendTags(privateData)) ;
if (!privateData->tagList) {
- debug_error("there is no tags\n");
+ debug_error(DEBUG, "there is no tags\n");
ret = MMFILE_TAGS_FAIL;
goto exception;
}
int res = 0;
if (!privateData || !privateData->fp) {
- debug_error("Invalid argument\n");
+ debug_error(DEBUG, "Invalid argument\n");
return MMFILE_TAGS_FAIL;
}
int res = 0;
if (!privateData || !privateData->fp) {
- debug_error("Invalid argument\n");
+ debug_error(DEBUG, "Invalid argument\n");
return MMFILE_TAGS_FAIL;
}
int ret = 0;
if (!privateData || !privateData->fp) {
- debug_error("Invalid argument\n");
+ debug_error(DEBUG, "Invalid argument\n");
return MMFILE_TAGS_FAIL;
}
tagData = mmfile_malloc(sizeof(tMMFileTags));
if (!tagData) {
- debug_error("mmfile_malloc tagData\n");
+ debug_error(DEBUG, "mmfile_malloc tagData\n");
return MMFILE_TAGS_FAIL;
}
int ret = 0;
if (NULL == formatContext) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
if (formatContext->pre_checked == 0) {
ret = MMFileFormatIsValidWAV(NULL, formatContext->uriFileName);
if (ret == 0) {
- debug_error("It is not wav file\n");
+ debug_error(DEBUG, "It is not wav file\n");
return MMFILE_FORMAT_FAIL;
}
}
{
bool ret = FALSE;
-#ifdef __MMFILE_TEST_MODE__
- debug_error("[sample rate %d, sample format %d]", sample_rate, bits_per_sample);
-#endif
+ debug_error(RELEASE, "[sample rate %d, sample format %d]", sample_rate, bits_per_sample);
if ((sample_rate >= 44100) && (bits_per_sample >= 24)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("UHQA CONTENT");
-#endif
+ debug_msg(RELEASE, "UHQA CONTENT");
ret = TRUE;
} else {
ret = FALSE;
int ret = 0;
if (formatContext == NULL) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
header = mmf_file_wave_get_header(formatContext->uriFileName);
if (header == NULL) {
- debug_error("error: mmf_file_wave_get_header\n");
+ debug_error(DEBUG, "error: mmf_file_wave_get_header\n");
goto exception;
}
waveinfo = mmfile_malloc(sizeof(MM_FILE_WAVE_INFO));
if (waveinfo == NULL) {
- debug_error("error: mmfile_malloc\n");
+ debug_error(DEBUG, "error: mmfile_malloc\n");
goto exception;
}
ret = mmf_file_wave_get_info(header, waveinfo);
if (ret == -1) {
- debug_error("error: mmf_file_wave_get_info\n");
+ debug_error(DEBUG, "error: mmf_file_wave_get_info\n");
goto exception;
}
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");
+ debug_error(DEBUG, "error: mmfile_malloc audio stream for wav\n");
return MMFILE_FORMAT_FAIL;
}
int mmfile_format_close_wav(MMFileFormatContext *formatContext)
{
if (formatContext == NULL) {
- debug_error("formatContext is NULL\n");
+ debug_error(DEBUG, "formatContext is NULL\n");
return MMFILE_FORMAT_FAIL;
}
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(DEBUG, "failed to read. size = %d\n", readed);
return 0;
}
/*open*/
ret = mmfile_open(&fp, src, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("open failed.\n");
+ debug_error(DEBUG, "open failed.\n");
goto failed;
}
mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (src_size < MMF_FILE_WAVE_HEADER_LEN) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
goto failed;
}
/*read chunk data*/
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(DEBUG, "read error. size = %d\n", readed);
goto failed;
}
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);
if (ret == 0) {
- debug_error("failed to seach 'fmt ' chunk\n");
+ debug_error(DEBUG, "failed to seach 'fmt ' chunk\n");
goto failed;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("fmt offset: %lld\n", offset);
-#endif
+ debug_msg(RELEASE, "fmt offset: %lld\n", offset);
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);
if (readed != MMF_FILE_WAVE_SUBCHUNK_LEN) {
- debug_error("read error. size = %d\n", readed);
+ debug_error(DEBUG, "read error. size = %d\n", readed);
goto failed;
}
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");
+ debug_msg(RELEASE, "----------------------------------------------\n");
+ debug_msg(RELEASE, "chunk size: %d\n", info->size);
+ debug_msg(RELEASE, "WAVE form Registration Number: 0x%04X\n", info->format);
+ debug_msg(RELEASE, "WAVE form wFormatTag ID: %s\n", _dump_codec_name(info->format));
+ debug_msg(RELEASE, "channel: %d\n", info->channel);
+ debug_msg(RELEASE, "sampling-rate: %d\n", info->sample_rate);
+ debug_msg(RELEASE, "byte-rate: %d\n", info->byte_rate);
+ debug_msg(RELEASE, "byte align: %d\n", info->block_align);
+ debug_msg(RELEASE, "bit per sample: %d\n", info->bits_per_sample);
+ debug_msg(RELEASE, "----------------------------------------------\n");
#endif
return 0;
#ifdef __MMFILE_MMAP_MODE__
*urifilename = mmfile_malloc(MMFILE_MMAP_URI_LEN + filename_len + 1);
if (!*urifilename) {
- debug_error("error: mmfile_malloc uriname\n");
+ debug_error(DEBUG, "error: mmfile_malloc uriname\n");
goto FILE_FORMAT_FAIL;
}
#else
*urifilename = mmfile_malloc(MMFILE_FILE_URI_LEN + filename_len + 1);
if (!*urifilename) {
- debug_error("error: mmfile_malloc uriname\n");
+ debug_error(DEBUG, "error: mmfile_malloc uriname\n");
goto FILE_FORMAT_FAIL;
}
ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto FILE_FORMAT_FAIL;
}
/* Check File format // */
/*///////////////////////////////////////////////////////////////////// */
-#ifdef __MMFILE_TEST_MODE__
- /*debug_msg ("Get codec type of [%s].\n", extansion_name); */
-#endif
+ /*debug_msg (RELEASE, "Get codec type of [%s].\n", extansion_name); */
switch (file_extansion) {
case MMFILE_EXT_MP4:
break;
default:
- debug_warning("probe file type=%s\n", fileName);
+ debug_warning(DEBUG, "probe file type=%s\n", fileName);
skip_index = -1;
goto PROBE_PROPER_FILE_TYPE;
break;
snprintf(tempURIBuffer, MMFILE_URI_MAX_LEN, "%s%lu:%u", MMFILE_MEM_URI, (unsigned long)fileSrc->memory.ptr, fileSrc->memory.size);
*urifilename = mmfile_strdup(tempURIBuffer);
if (!*urifilename) {
- debug_error("error: uri is NULL\n");
+ debug_error(DEBUG, "error: uri is NULL\n");
goto FILE_FORMAT_FAIL;
}
ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto FILE_FORMAT_FAIL;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("uri: %s\n", *urifilename);
-#endif
+ debug_msg(RELEASE, "uri: %s\n", *urifilename);
switch (fileSrc->memory.format) {
case MM_FILE_FORMAT_3GP: {
}
default: {
- debug_warning("probe fileformat type=%d (%d: autoscan)\n", fileSrc->memory.format, MM_FILE_FORMAT_INVALID);
+ debug_warning(DEBUG, "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(DEBUG, "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
+ debug_msg(RELEASE, "search index = [%d]\n", index);
switch (index) {
case MM_FILE_FORMAT_QT:
case MM_FILE_FORMAT_VOB:
case MM_FILE_FORMAT_JPG:
default: {
- debug_error("error: invaild format enum[%d]\n", index);
+ debug_error(RELEASE, "error: invaild format enum[%d]\n", index);
break;
}
}
FILE_FORMAT_FAIL:
if (index == MM_FILE_FORMAT_NUM)
- debug_error("Can't probe file type\n");
+ debug_error(DEBUG, "Can't probe file type\n");
*formatEnum = -1;
static int _mmfile_format_close(MMFileFormatContext *formatContext, bool clean_all)
{
if (NULL == formatContext) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
MMFileFormatContext *formatObject = NULL;
if (NULL == fileSrc) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
/* create formatContext object */
formatObject = mmfile_malloc(sizeof(MMFileFormatContext));
if (NULL == formatObject) {
- debug_error("error: mmfile_malloc fail for formatObject\n");
+ debug_error(DEBUG, "error: mmfile_malloc fail for formatObject\n");
*formatContext = NULL;
return MMFILE_FORMAT_FAIL;
}
*/
ret = _PreprocessFile(fileSrc, &formatObject->uriFileName, &formatObject->formatType);
if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error("error: _PreprocessFile fail\n");
+ debug_error(DEBUG, "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(DEBUG, "error: Not implemented \n");
ret = MMFILE_FORMAT_FAIL;
goto find_valid_handler;
}
ret = MMFileOpenFunc[formatObject->formatType](formatObject);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error("error: Try other formats\n");
+ debug_error(DEBUG, "error: Try other formats\n");
ret = MMFILE_FORMAT_FAIL;
/* goto find_valid_handler; */
goto exception;
for (index = 0; index < MM_FILE_FORMAT_NUM + 1; index++) {
if (NULL == MMFileOpenFunc[index]) {
- debug_error("error: Not implemented \n");
+ debug_error(DEBUG, "error: Not implemented \n");
ret = MMFILE_FORMAT_FAIL;
continue;
}
formatObject->formatType = index;
if (index == MM_FILE_FORMAT_NUM + 1 && MMFILE_FORMAT_FAIL == ret) {
- debug_error("can't find file format handler\n");
+ debug_error(DEBUG, "can't find file format handler\n");
_CleanupFrameContext(formatObject, true);
ret = MMFILE_FORMAT_FAIL;
goto exception;
int mmfile_format_read_stream(MMFileFormatContext *formatContext)
{
if (NULL == formatContext || NULL == formatContext->ReadStream) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
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");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
int mmfile_format_read_tag(MMFileFormatContext *formatContext)
{
if (NULL == formatContext || NULL == formatContext->ReadTag) {
- debug_error("error: invalid params\n");
+ debug_error(DEBUG, "error: invalid params\n");
return MMFILE_FORMAT_FAIL;
}
#endif
#define LOG_TAG "MM_FILEINFO"
+#define RELEASE 0
+#define DEBUG 1
+
+#ifdef __MMFILE_TEST_MODE__
+#define DEBUG_MODE 1
+#else
+#define DEBUG_MODE 0
+#endif
/*#define LOG_COLOR */
#define FONT_COLOR_CYAN "\033[36m"
#define FONT_COLOR_GRAY "\033[37m"
-#define debug_log(fmt, arg...) do { \
- LOGD(FONT_COLOR_RESET fmt, ##arg); \
+#define debug_log(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGD(FONT_COLOR_RESET fmt, ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGD(FONT_COLOR_RESET fmt, ##arg); \
+ } \
} while (0)
-#define debug_msg(fmt, arg...) do { \
- LOGD(FONT_COLOR_RESET fmt, ##arg); \
+#define debug_msg(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGD(FONT_COLOR_RESET fmt, ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGD(FONT_COLOR_RESET fmt, ##arg); \
+ } \
} while (0)
-#define debug_warning(fmt, arg...) do { \
- LOGW(FONT_COLOR_GREEN fmt, ##arg); \
+#define debug_warning(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGW(FONT_COLOR_GREEN fmt, ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGW(FONT_COLOR_GREEN fmt, ##arg); \
+ } \
} while (0)
-#define debug_error(fmt, arg...) do { \
- LOGE(FONT_COLOR_RED fmt, ##arg); \
+#define debug_error(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGE(FONT_COLOR_RED fmt, ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGE(FONT_COLOR_RED fmt, ##arg); \
+ } \
} while (0)
-#define debug_fenter() do { \
- LOGE(FONT_COLOR_RESET "<ENTER> \n"); \
+#define debug_fenter(mode) do { \
+ if(mode == DEBUG) { \
+ LOGE(FONT_COLOR_RESET "<ENTER> \n"); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGE(FONT_COLOR_RESET "<ENTER> \n"); \
+ } \
} while (0)
-#define debug_fleave() do { \
- LOGE(FONT_COLOR_RESET "<LEAVE> \n"); \
+#define debug_fleave(mode) do { \
+ if(mode == DEBUG) { \
+ LOGE(FONT_COLOR_RESET "<LEAVE> \n"); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGE(FONT_COLOR_RESET "<LEAVE> \n"); \
+ } \
} while (0)
#else
-#define debug_log(fmt, arg...) do { \
- LOGD(" "fmt"", ##arg); \
+#define debug_log(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGD(" "fmt"", ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGD(" "fmt"", ##arg); \
+ } \
} while (0)
-#define debug_msg(fmt, arg...) do { \
- LOGD(" "fmt"", ##arg); \
+#define debug_msg(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGD(" "fmt"", ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGD(" "fmt"", ##arg); \
+ } \
} while (0)
-#define debug_warning(fmt, arg...) do { \
- LOGW(" "fmt"", ##arg); \
+#define debug_warning(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGW(" "fmt"", ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGW(" "fmt"", ##arg); \
+ } \
} while (0)
-#define debug_error(fmt, arg...) do { \
- LOGE(" "fmt"", ##arg); \
+#define debug_error(mode, fmt, arg...) do { \
+ if(mode == DEBUG) { \
+ LOGE(" "fmt"", ##arg); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGE(" "fmt"", ##arg); \
+ } \
} while (0)
-#define debug_fenter() do { \
- LOGE("<ENTER> \n"); \
+#define debug_fenter(mode) do { \
+ if(mode == DEBUG) { \
+ LOGE("<ENTER> \n"); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGE("<ENTER> \n"); \
+ } \
} while (0)
-#define debug_fleave() do { \
- LOGE("<LEAVE> \n"); \
+#define debug_fleave(mode) do { \
+ if(mode == DEBUG) { \
+ LOGE("<LEAVE> \n"); \
+ } else if(mode == RELEASE) { \
+ if(DEBUG_MODE == 1) \
+ LOGE("<LEAVE> \n"); \
+ } \
} while (0)
#endif
formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
if (!formatFuncHandle) {
- debug_error("error: %s\n", "libmmfile_formats.so open error");
+ debug_error(DEBUG, "error: %s\n", "libmmfile_formats.so open error");
ret = 0;
goto exception;
}
!mmfile_format_read_tag ||
!mmfile_format_close) {
- debug_error("error: %s\n", "format function load error");
+ debug_error(DEBUG, "error: %s\n", "format function load error");
ret = 0;
goto exception;
}
codecFuncHandle = dlopen(MMFILE_CODEC_SO_FILE_NAME, RTLD_LAZY | RTLD_GLOBAL);
if (!codecFuncHandle) {
- debug_error("error: %s\n", "libmmfile_codecs.so open error");
+ debug_error(DEBUG, "error: %s\n", "libmmfile_codecs.so open error");
ret = 0;
goto exception;
}
mmfile_codec_close = dlsym(codecFuncHandle, "mmfile_codec_close");
if (!mmfile_codec_open || !mmfile_codec_decode || !mmfile_codec_close) {
- debug_error("error: %s\n", "codec function load error");
+ debug_error(DEBUG, "error: %s\n", "codec function load error");
ret = 0;
goto exception;
}
static void _unload_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
{
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if (pHandle->formatFuncHandle) {
dlclose(pHandle->formatFuncHandle);
dlclose(pHandle->codecFuncHandle);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
}
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(DEBUG, "file [%s] not found.\n", to_access);
}
}
return !ret;
ret = mmfile_format_open(&formatContext, src);
if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
- debug_error("error: mmfile_format_open\n");
+ debug_error(DEBUG, "error: mmfile_format_open\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto exception;
}
formatContext->cdis = 1;
ret = mmfile_format_read_stream(formatContext);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error("error: mmfile_format_read_stream\n");
+ debug_error(DEBUG, "error: mmfile_format_read_stream\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto exception;
}
ret = mmfile_format_read_frame(formatContext, timestamp, &frameContext);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error("error: mmfile_format_read_frame\n");
+ debug_error(DEBUG, "error: mmfile_format_read_frame\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto warning;
}
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(DEBUG, "error: mmfile_codec_open\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto warning;
}
ret = mmfile_codec_decode(codecContext, &decodedFrame);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_error("error: mmfile_codec_decode\n");
+ debug_error(DEBUG, "error: mmfile_codec_decode\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto warning;
}
/* set video thumbnail */
formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
if (NULL == formatContext->thumbNail) {
- debug_error("error: mmfile_malloc\n");
+ debug_error(DEBUG, "error: mmfile_malloc\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto warning;
}
} else {
formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
if (NULL == formatContext->thumbNail) {
- debug_error("error: mmfile_format_read_frame\n");
+ debug_error(DEBUG, "error: mmfile_format_read_frame\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto warning;
}
ret = mmfile_format_open(&formatContext, src);
if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
- debug_error("error: mmfile_format_open\n");
+ debug_error(DEBUG, "error: mmfile_format_open\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto exception;
}
ret = mmfile_format_read_tag(formatContext);
if (MMFILE_FORMAT_FAIL == ret) {
- debug_warning("reading tag is fail\n");
+ debug_warning(DEBUG, "reading tag is fail\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto exception;
}
va_list var_args;
if (!attrs) {
- debug_error("Invalid arguments [attrs 0]\n");
+ debug_error(DEBUG, "Invalid arguments [attrs 0]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (first_attribute_name == NULL) {
- debug_error("Invalid arguments [first_attribute_name null]\n");
+ debug_error(DEBUG, "Invalid arguments [first_attribute_name null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (ret != FILEINFO_ERROR_NONE) {
if (err_attr_name) {
- debug_error("failed to get %s\n", *err_attr_name);
+ debug_error(DEBUG, "failed to get %s\n", *err_attr_name);
}
}
AvSynclyricsInfo *sync_lyric_item = NULL;
GList *synclyrics_list = NULL;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if ((mmf_attrs_t *)tag_attrs == NULL) {
- debug_error("invalid handle");
+ debug_error(DEBUG, "invalid handle");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
if (ret != FILEINFO_ERROR_NONE) {
-#ifdef __MMFILE_TEST_MODE__
- debug_warning("get data fail");
-#endif
+ debug_warning(RELEASE, "get data fail");
return ret;
}
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
+ debug_warning(RELEASE, "synclyric item is NULL");
return FILEINFO_ERROR_ATTR_NOT_EXIST;
}
*lyrics = sync_lyric_item->lyric_info;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_warning("synclyrics_list is NULL");
-#endif
+ debug_warning(RELEASE, "synclyrics_list is NULL");
return FILEINFO_ERROR_ATTR_NOT_EXIST;
}
mmf_attrs_t *attrs = NULL;
MMFileSourceType src;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
/* Check argument here */
if (tag_attrs == NULL) {
- debug_error("Invalid arguments [tag null]\n");
+ debug_error(DEBUG, "Invalid arguments [tag null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (filename == NULL) {
- debug_error("Invalid arguments [filename null]\n");
+ debug_error(DEBUG, "Invalid arguments [filename null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (strlen(filename) == 0) {
- debug_error("Invalid arguments [filename size 0]\n");
+ debug_error(DEBUG, "Invalid arguments [filename size 0]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret != FILEINFO_ERROR_NONE) {
mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error("failed to get tag: %s\n", filename);
+ debug_error(DEBUG, "failed to get tag: %s\n", filename);
}
*tag_attrs = (MMHandleType)attrs;
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
GList *synclyrics_list = NULL;
int ret = FILEINFO_ERROR_NONE;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if ((mmf_attrs_t *)tag_attrs == NULL) {
- debug_error("invalid handle.\n");
+ debug_error(DEBUG, "invalid handle.\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
mmf_attrs_free(tag_attrs);
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
/* Check argument here */
if (contents_attrs == NULL) {
- debug_error("Invalid arguments [contents null]\n");
+ debug_error(DEBUG, "Invalid arguments [contents null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (filename == NULL) {
- debug_error("Invalid arguments [filename null]\n");
+ debug_error(DEBUG, "Invalid arguments [filename null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (strlen(filename) == 0) {
- debug_error("Invalid arguments [filename size 0]\n");
+ debug_error(DEBUG, "Invalid arguments [filename size 0]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#ifdef CHECK_TIME
- debug_msg("_load_dynamic_functions() = %lld\n", gettime() - ti);
+ debug_msg(DEBUG, "_load_dynamic_functions() = %lld\n", gettime() - ti);
#endif
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret != FILEINFO_ERROR_NONE) {
mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error("failed to get contents: %s\n", filename);
+ debug_error(DEBUG, "failed to get contents: %s\n", filename);
}
*contents_attrs = (MMHandleType) attrs;
_unload_dynamic_functions(&func_handle);
#ifdef CHECK_TIME
- debug_msg("_unload_dynamic_functions() = %lld\n", gettime() - ti);
+ debug_msg(DEBUG, "_unload_dynamic_functions() = %lld\n", gettime() - ti);
#endif
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
/*MMFILE_PARSE_INFO parse = {0, };*/
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
/* Check argument here */
if (tag_attrs == NULL || data == NULL) {
- debug_error("Invalid arguments\n");
+ debug_error(DEBUG, "Invalid arguments\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret != FILEINFO_ERROR_NONE) {
mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error("failed to get tag");
+ debug_error(DEBUG, "failed to get tag");
}
*tag_attrs = (MMHandleType)attrs;
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
/* Check argument here */
if (contents_attrs == NULL || data == NULL) {
- debug_error("Invalid arguments\n");
+ debug_error(DEBUG, "Invalid arguments\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret != FILEINFO_ERROR_NONE) {
mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error("failed to get contents");
+ debug_error(DEBUG, "failed to get contents");
}
*contents_attrs = (MMHandleType)attrs;
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
void *thumbnail = NULL;
int ret = FILEINFO_ERROR_NONE;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if ((mmf_attrs_t *)contents_attrs == NULL) {
- debug_error("invalid handle.\n");
+ debug_error(DEBUG, "invalid handle.\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
mmf_attrs_free(contents_attrs);
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
if (filename == NULL || strlen(filename) == 0 || audio_stream_num == NULL || video_stream_num == NULL) {
- debug_error("Invalid arguments\n");
+ debug_error(DEBUG, "Invalid arguments\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
ret = _get_contents_info(NULL, &src, &parse);
if (ret != FILEINFO_ERROR_NONE) {
- debug_error("failed to get stream info: %s\n", filename);
+ debug_error(DEBUG, "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);
+ debug_error(DEBUG, "empty header. retry to get stream info: %s\n", filename);
parse.type = MM_FILE_PARSE_TYPE_NORMAL;
ret = _get_contents_info(NULL, &src, &parse);
}
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret != FILEINFO_ERROR_NONE) {
mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error("failed to get contents: %s\n", filename);
+ debug_error(DEBUG, "failed to get contents: %s\n", filename);
}
*contents_attrs = (MMHandleType) attrs;
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
MMFILE_PARSE_INFO parse = {0, };
int ret = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_fenter();
-#endif
+ debug_fenter(RELEASE);
#ifdef __MMFILE_DYN_LOADING__
MMFILE_FUNC_HANDLE func_handle;
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret != FILEINFO_ERROR_NONE) {
mmf_attrs_free((MMHandleType)attrs);
attrs = NULL;
- debug_error("failed to get contents: %s\n", filename);
+ debug_error(DEBUG, "failed to get contents: %s\n", filename);
}
*contents_attrs = (MMHandleType) attrs;
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
void *formatFuncHandle = NULL;
if (path == NULL) {
- debug_error("Invalid arguments [Path is Null]\n");
+ debug_error(DEBUG, "Invalid arguments [Path is Null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
/* Get from function argument */
formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
if (!formatFuncHandle) {
- debug_error("error : dlopen");
+ debug_error(DEBUG, "error : dlopen");
goto exception;
}
mmfile_format_get_frame = dlsym(formatFuncHandle, "mmfile_format_get_frame");
if (!mmfile_format_get_frame) {
- debug_error("error : load library");
+ debug_error(DEBUG, "error : load library");
goto exception;
}
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("file path [%s] is_accurate [%d]", path, is_accurate);
-#endif
+ debug_msg(RELEASE, "file path [%s] is_accurate [%d]", path, is_accurate);
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(DEBUG, "error : get frame");
goto exception;
}
void *formatFuncHandle = NULL;
if (data == NULL) {
- debug_error("Invalid arguments [data is Null]\n");
+ debug_error(DEBUG, "Invalid arguments [data is Null]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
if (datasize == 0) {
- debug_error("Invalid arguments [datasize is zero]\n");
+ debug_error(DEBUG, "Invalid arguments [datasize is zero]\n");
return FILEINFO_ERROR_INVALID_ARGUMENT;
}
/* Get from function argument */
formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
if (!formatFuncHandle) {
- debug_error("error : dlopen");
+ debug_error(DEBUG, "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");
+ debug_error(DEBUG, "error : load library");
goto exception;
}
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);
-#endif
+ debug_msg(RELEASE, "data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);
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(DEBUG, "error : get frame");
goto exception;
}
ret = _load_dynamic_functions(&func_handle);
if (ret == 0) {
- debug_error("load library error\n");
+ debug_error(DEBUG, "load library error\n");
return FILEINFO_ERROR_FILE_INTERNAL;
}
#endif
/*set attrs*/
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(DEBUG, "attribute internal error.\n");
ret = FILEINFO_ERROR_FILE_INTERNAL;
goto END;
}
if (ret == FILEINFO_ERROR_NONE) {
*is_uhqa = parse.is_uhqa;
} else {
- debug_error("_get_contents_info failed\n");
+ debug_error(DEBUG, "_get_contents_info failed\n");
*is_uhqa = FALSE;
}
_unload_dynamic_functions(&func_handle);
#endif
-#ifdef __MMFILE_TEST_MODE__
- debug_fleave();
-#endif
+ debug_fleave(RELEASE);
return ret;
}
\ No newline at end of file
Name: libmm-fileinfo
Summary: Media Fileinfo
-Version: 0.6.53
+Version: 0.6.55
Release: 0
Group: System/Libraries
License: Apache-2.0
int fileNameLen = 0;
if (!handle || !Func || !filename || !Func->mmfile_open) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
err = MMFILE_IO_FAILED;
goto fail;
}
pHandle = mmfile_malloc(sizeof(MMFileIOHandle));
if (!pHandle) {
- debug_error("mmfile_malloc: pHandle\n");
+ debug_error(DEBUG, "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
+
+ debug_msg(RELEASE, "[%d, %s]\n", fileNameLen, filename);
+
pHandle->fileName = mmfile_malloc(fileNameLen + 1);
if (!pHandle->fileName) {
- debug_error("mmfile_malloc: pHandle->fileName\n");
+ debug_error(DEBUG, "mmfile_malloc: pHandle->fileName\n");
err = MMFILE_IO_FAILED;
goto fail;
}
err = Func->mmfile_open(pHandle, filename, flags);
if (err < 0) {
- debug_error("mmfile_open: pHandle->fileName\n");
+ debug_error(DEBUG, "mmfile_open: pHandle->fileName\n");
err = MMFILE_IO_FAILED;
goto fail;
}
char *pHandleName = NULL;
if (!handle || !filename) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_IO_FAILED;
}
int fd = 0;
if (!handle || !filename) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_IO_FAILED;
}
fd = open(filename, access, 0666);
if (fd < 0) {
- debug_error("open error\n");
+ debug_error(DEBUG, "open error\n");
return MMFILE_IO_FAILED;
}
privateData = mmfile_malloc(sizeof(tMMFORMAT_FILEIO_DATA));
if (!privateData) {
close(fd);
- debug_error("calloc privateData\n");
+ debug_error(DEBUG, "calloc privateData\n");
return MMFILE_IO_FAILED;
}
readSize = read(privateData->fd, buf, size);
if (readSize < 0) {
- debug_error("read\n");
+ debug_error(RELEASE, "read\n");
return MMFILE_IO_FAILED;
}
writtenSize = write(privateData->fd, buf, size);
if (writtenSize < 0) {
- debug_error("write\n");
+ debug_error(RELEASE, "write\n");
return MMFILE_IO_FAILED;
}
char **splitedString = NULL;
if (!handle || !filename || !handle->iofunc || !handle->iofunc->handleName) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_IO_FAILED;
}
splitedString = mmfile_strsplit(filename, ":");
if (splitedString == NULL) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_IO_FAILED;
}
if (!splitedString[0] || !splitedString[1]) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
goto exception;
}
memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
if (!memHandle) {
- debug_error("error: mmfile_malloc memHandle\n");
+ debug_error(DEBUG, "error: mmfile_malloc memHandle\n");
goto exception;
}
int len = 0;
if (!h || !h->privateData || !buf) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
memHandle = h->privateData;
if (!memHandle->ptr) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
int len = 0;
if (!h || !h->privateData || !buf) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
long tmp_offset = 0;
if (!h || !h->privateData) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
/*check validation*/
if (tmp_offset < 0) {
- debug_error("invalid file offset\n");
+ debug_error(DEBUG, "invalid file offset\n");
return MMFILE_IO_FAILED;
}
MMFmemIOHandle *memHandle = NULL;
if (!h || !h->privateData) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
MMFmemIOHandle *memHandle = NULL;
if (!h || !h->privateData) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
int access = 0;
if (!handle || !filename || !handle->iofunc || !handle->iofunc->handleName) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_IO_FAILED;
}
mmapHandle = mmfile_malloc(sizeof(MMFMMapIOHandle));
if (!mmapHandle) {
- debug_error("error: mmfile_malloc mmapHandle\n");
+ debug_error(DEBUG, "error: mmfile_malloc mmapHandle\n");
return MMFILE_IO_FAILED;
}
mmapHandle->fd = open(filename, access, 0666);
if (mmapHandle->fd < 0) {
- debug_error("error: open error: %s\n", filename);
+ debug_error(DEBUG, "error: open error: %s\n", filename);
goto exception;
}
if (fstat(mmapHandle->fd, &finfo) == -1) {
- debug_error("error: fstat\n");
+ debug_error(DEBUG, "error: fstat\n");
goto exception;
}
if (!S_ISREG(finfo.st_mode)) {
- debug_error("error: it is not regular file\n");
+ debug_error(DEBUG, "error: it is not regular file\n");
goto exception;
}
}
if (mmapHandle->ptr == (void *)-1) {
- debug_error("error: mmap\n");
+ debug_error(DEBUG, "error: mmap\n");
mmapHandle->ptr = NULL;
goto exception;
}
int len = 0;
if (!h || !h->privateData || !buf) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
int len = 0;
if (!h || !h->privateData || !buf) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
long tmp_offset = 0;
if (!h || !h->privateData) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
/*check validation*/
if (tmp_offset < 0) {
- debug_error("invalid file offset\n");
+ debug_error(DEBUG, "invalid file offset\n");
return MMFILE_IO_FAILED;
}
MMFMMapIOHandle *mmapHandle = NULL;
if (!h || !h->privateData) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
MMFMMapIOHandle *mmapHandle = NULL;
if (!h || !h->privateData) {
- debug_error("invalid para\n");
+ debug_error(DEBUG, "invalid para\n");
return MMFILE_IO_FAILED;
}
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);
+ debug_msg(DEBUG, "[%s]character set is simplified chinese", lang);
index = MMFILE_LANGUAGE_SIM_CHINA;
} else {
- debug_msg("[%s]character set is traditional chinese", lang);
+ debug_msg(DEBUG, "[%s]character set is traditional chinese", lang);
index = MMFILE_LANGUAGE_TRA_CHINA;
}
} else if (strncmp(lang, eng_prefix, strlen(eng_prefix)) == 0) {
/* This case is selected language is engilish
In case of engilish, the character set is related with region of target binary */
- debug_msg("[%s]character set is engilish", lang);
+ debug_msg(DEBUG, "[%s]character set is engilish", lang);
index = MMFILE_LANGUAGE_ENGLISH;
} else if (strncmp(lang, jpn_lang, strlen(jpn_lang)) == 0) {
/* This case is selected language is japanease */
- debug_msg("[%s]character set is japanease", lang);
+ debug_msg(DEBUG, "[%s]character set is japanease", lang);
index = MMFILE_LANGUAGE_JAPAN;
} else {
- debug_error("use default character set");
+ debug_error(DEBUG, "use default character set");
index = MMFILE_LANGUAGE_ENGLISH;
}
} else {
- debug_error("language value is NULL, use default character set");
+ debug_error(DEBUG, "language value is NULL, use default character set");
index = MMFILE_LANGUAGE_ENGLISH;
}
index = _MMFileUtilGetLocaleindex();
if (index < 0 || index >= MMFILE_LANGUAGE_MAX) {
- debug_error("invalid index\n");
+ debug_error(DEBUG, "invalid index\n");
err = MMFILE_UTIL_FAIL;
return NULL;
}
if (tmp) {
memset(tmp, 0x00, size);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## %p = malloc (%d) by %s() %d\n", tmp, size, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## %p = malloc (%d) by %s() %d\n", tmp, size, func, line);
}
return tmp;
}
void *tmp = calloc(nmemb, size);
if (tmp) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## %p = calloc (%d, %d) by %s() %d\n", tmp, nmemb, size, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## %p = calloc (%d, %d) by %s() %d\n", tmp, nmemb, size, func, line);
}
return tmp;
}
void mmfile_free_debug(void *ptr, const char *func, unsigned int line)
{
if (ptr) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## free (%p) by %s() %d\n", ptr, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## free (%p) by %s() %d\n", ptr, func, line);
free(ptr);
}
}
void *tmp = realloc(ptr, size);
if (tmp) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## %p = realloc (%p, %d) by %s() %d\n", tmp, ptr, size, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## %p = realloc (%p, %d) by %s() %d\n", tmp, ptr, size, func, line);
}
return tmp;
}
EXPORT_API
void *mmfile_memset_debug(void *s, int c, unsigned int n, const char *func, unsigned int line)
{
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## memset (%p, %d, %d) by %s() %d\n", s, c, n, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## memset (%p, %d, %d) by %s() %d\n", s, c, n, func, line);
+
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)
{
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## memcpy (%p, %p, %d) by %s() %d\n", dest, src, n, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## memcpy (%p, %p, %d) by %s() %d\n", dest, src, n, func, line);
+
return memcpy(dest, src, n);
}
int table_size = sizeof(MMFILE_FFMPEG_MIME_TABLE) / sizeof(MMFileAVMimeType);
if (NULL == mime || NULL == ffmpegFormat) {
- debug_error("error: mmfile_util_get_format\n");
+ debug_error(DEBUG, "error: mmfile_util_get_format\n");
return MMFILE_UTIL_FAIL;
}
}
if (i == table_size) {
- debug_error("error: not found[%s]\n", mime);
+ debug_error(DEBUG, "error: not found[%s]\n", mime);
return MMFILE_UTIL_FAIL;
}
int table_size = sizeof(MMFILE_FFMPEG_MIME_TABLE) / sizeof(MMFileAVMimeType);
if (NULL == mime || NULL == ext) {
- debug_error("error: mmfile_util_get_file_ext\n");
+ debug_error(DEBUG, "error: mmfile_util_get_file_ext\n");
return MMFILE_UTIL_FAIL;
}
}
if (i == table_size) {
- debug_error("error: not found[%s]\n", mime);
+ debug_error(DEBUG, "error: not found[%s]\n", mime);
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "formatType = %d\n", in->formatType);
+ debug_msg(DEBUG, "commandType = %d\n", in->commandType);
+ debug_msg(DEBUG, "duration = %d\n", in->duration);
+ debug_msg(DEBUG, "videoTotalTrackNum = %d\n", in->videoTotalTrackNum);
+ debug_msg(DEBUG, "audioTotalTrackNum = %d\n", in->audioTotalTrackNum);
+ debug_msg(DEBUG, "nbStreams = %d\n", in->nbStreams);
+ debug_msg(DEBUG, "audioStreamId = %d\n", in->audioStreamId);
+ debug_msg(DEBUG, "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(DEBUG, "VstreamType = %d\n", in->streams[MMFILE_VIDEO_STREAM]->streamType);
+ debug_msg(DEBUG, "VcodecId = %d\n", in->streams[MMFILE_VIDEO_STREAM]->codecId);
+ debug_msg(DEBUG, "VbitRate = %d\n", in->streams[MMFILE_VIDEO_STREAM]->bitRate);
+ debug_msg(DEBUG, "VframePerSec = %d\n", in->streams[MMFILE_VIDEO_STREAM]->framePerSec);
+ debug_msg(DEBUG, "Vwidth = %d\n", in->streams[MMFILE_VIDEO_STREAM]->width);
+ debug_msg(DEBUG, "Vheight = %d\n", in->streams[MMFILE_VIDEO_STREAM]->height);
+ debug_msg(DEBUG, "VnbChannel = %d\n", in->streams[MMFILE_VIDEO_STREAM]->nbChannel);
+ debug_msg(DEBUG, "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(DEBUG, "AstreamType = %d\n", in->streams[MMFILE_AUDIO_STREAM]->streamType);
+ debug_msg(DEBUG, "AcodecId = %d\n", in->streams[MMFILE_AUDIO_STREAM]->codecId);
+ debug_msg(DEBUG, "AbitRate = %d\n", in->streams[MMFILE_AUDIO_STREAM]->bitRate);
+ debug_msg(DEBUG, "AframePerSec = %d\n", in->streams[MMFILE_AUDIO_STREAM]->framePerSec);
+ debug_msg(DEBUG, "Awidth = %d\n", in->streams[MMFILE_AUDIO_STREAM]->width);
+ debug_msg(DEBUG, "Aheight = %d\n", in->streams[MMFILE_AUDIO_STREAM]->height);
+ debug_msg(DEBUG, "AnbChannel = %d\n", in->streams[MMFILE_AUDIO_STREAM]->nbChannel);
+ debug_msg(DEBUG, "AsamplePerSec = %d\n", in->streams[MMFILE_AUDIO_STREAM]->samplePerSec);
}
}
}
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(DEBUG, "title = %s\n", in->title);
+ if (in->artist) debug_msg(DEBUG, "artist = %s\n", in->artist);
+ if (in->author) debug_msg(DEBUG, "author = %s\n", in->author);
+ if (in->composer) debug_msg(DEBUG, "composer = %s\n", in->composer);
+ if (in->album) debug_msg(DEBUG, "album = %s\n", in->album);
+ if (in->album_artist) debug_msg(DEBUG, "album_artist = %s\n", in->album_artist);
+ if (in->copyright) debug_msg(DEBUG, "copyright = %s\n", in->copyright);
+ if (in->comment) debug_msg(DEBUG, "comment = %s\n", in->comment);
+ if (in->genre) debug_msg(DEBUG, "genre = %s\n", in->genre);
+ if (in->year) debug_msg(DEBUG, "year = %s\n", in->year);
+ if (in->recDate) debug_msg(DEBUG, "recDate = %s\n", in->recDate);
+ if (in->tagTrackNum) debug_msg(DEBUG, "tagTrackNum = %s\n", in->tagTrackNum);
+ if (in->artworkMime) debug_msg(DEBUG, "artworkMime = %s\n", in->artworkMime);
+ debug_msg(DEBUG, "artworksize = %d\n", in->artworkSize);
+ if (in->artwork) debug_msg(DEBUG, "artwork = %p\n", in->artwork);
+ if (in->classification) debug_msg(DEBUG, "classification = %s\n", in->classification);
}
}
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(DEBUG, "in->bCompressed = %d\n", in->bCompressed);
+ debug_msg(DEBUG, "in->frameData = %p\n", in->frameData);
+ debug_msg(DEBUG, "in->frameHeight = %d\n", in->frameHeight);
+ debug_msg(DEBUG, "in->frameWidth = %d\n", in->frameWidth);
+ debug_msg(DEBUG, "in->frameSize = %d\n", in->frameSize);
+ debug_msg(DEBUG, "in->configLenth = %d\n", in->configLenth);
+ debug_msg(DEBUG, "in->configData = %p\n", in->configData);
}
}
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(DEBUG, "codecType = %d\n", in->codecType);
+ debug_msg(DEBUG, "codec id = %d\n", in->codecId);
}
}
int n = 0;
if (NULL == wText) {
- debug_error("wText is NULL\n");
+ debug_error(DEBUG, "wText is NULL\n");
return MMFILE_UTIL_FAIL;
}
char *tmp = g_convert(str, len, to_codeset, from_codeset, bytes_read, bytes_written, NULL);
if (tmp) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## %p = g_convert (%p, %u, %p, %p, %p ,%p, %p, %u) by %s() %d\n",
+ debug_msg(RELEASE, "## 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);
-#endif
}
return tmp;
temp = strdup(str);
if (temp) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("## DEBUG ## %p = strdup (%p) by %s() %d\n", temp, str, func, line);
-#endif
+ debug_msg(RELEASE, "## DEBUG ## %p = strdup (%p) by %s() %d\n", temp, str, func, line);
}
return temp;
int n = 0;
if (NULL == wText) {
- debug_error("wText is NULL\n");
+ debug_error(DEBUG, "wText is NULL\n");
return MMFILE_UTIL_FAIL;
}
ucsd = ucsdet_open(&status);
if (U_FAILURE(status)) {
- debug_error("fail to ucsdet_open\n");
+ debug_error(DEBUG, "fail to ucsdet_open\n");
return NULL;
}
ucsdet_setText(ucsd, str, strlen(str), &status);
if (U_FAILURE(status)) {
- debug_error("fail to ucsdet_setText\n");
+ debug_error(DEBUG, "fail to ucsdet_setText\n");
goto done;
}
ucm = ucsdet_detect(ucsd, &status);
if (U_FAILURE(status)) {
- debug_error("fail to ucsdet_detect\n");
+ debug_error(DEBUG, "fail to ucsdet_detect\n");
goto done;
}
if (ucm == NULL) {
- debug_error("fail to ucsdet_detect\n");
+ debug_error(DEBUG, "fail to ucsdet_detect\n");
goto done;
}
charset = ucsdet_getName(ucm, &status);
if (U_FAILURE(status)) {
- debug_error("fail to ucsdet_getName\n");
+ debug_error(DEBUG, "fail to ucsdet_getName\n");
charset = NULL;
goto done;
}
/*if converting failed, return duplicated source string.*/
if (result == NULL) {
-#ifdef __MMFILE_TEST_MODE__
- debug_warning("text encoding failed.[%s][%d]\n", str, len);
+ debug_warning(RELEASE, "text encoding failed.[%s][%d]\n", str, len);
+
if (err != NULL) {
- debug_warning("Error msg [%s]", err->message);
+ debug_warning(DEBUG, "Error msg [%s]", err->message);
g_error_free(err);
}
-#endif
+
written_len = 0;
} else {
/* check carrige return */
char *temp_text = NULL;
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "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");
+ debug_error(DEBUG, "Text is NULL\n");
goto exception;
}
texttag.text = mmfile_malloc(textBytes);
if (!texttag.text) {
- debug_error("malloc fail for text box\n");
+ debug_error(DEBUG, "malloc fail for text box\n");
ret = MMFILE_UTIL_FAIL;
goto exception;
}
readed = mmfile_read(fp, (unsigned char *)texttag.text, textBytes);
if (readed != textBytes) {
- debug_error("read text fail\n");
+ debug_error(DEBUG, "read text fail\n");
ret = MMFILE_UTIL_FAIL;
goto exception;
}
break;
}
default: {
- debug_warning("Not supported Text Tag type[%d]\n", eTag);
+ debug_warning(DEBUG, "Not supported Text Tag type[%d]\n", eTag);
break;
}
}
char temp_year[MAX_YEAR_BUFFER] = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "read yeartag header fail\n");
goto exception;
}
MMFILE_3GP_ALBUM_TAGBOX albumbox = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "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
+ debug_msg(RELEASE, "albumTitleLen=%d\n", albumTitleLen);
albumbox.albumtile = mmfile_malloc(albumTitleLen + 1); /* 1: for null char */
if (!albumbox.albumtile) {
- debug_error("malloc fail for album title text\n");
+ debug_error(DEBUG, "malloc fail for album title text\n");
goto exception;
}
readed = mmfile_read(fp, (unsigned char *)albumbox.albumtile, albumTitleLen);
if (readed != albumTitleLen) {
- debug_error("read album title fail\n");
+ debug_error(DEBUG, "read album title fail\n");
goto exception;
}
trackFlags = 0;
readed = mmfile_read(fp, (unsigned char *)&(albumbox.albumtile[albumTitleLen]), 1);
if (readed != 1) {
- debug_error("read album title fail\n");
+ debug_error(DEBUG, "read album title fail\n");
goto exception;
}
albumbox.albumtile[albumTitleLen] = '\0';
formatContext->album = temp_text;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("formatContext->album=%s, strlen=%d\n", formatContext->album, strlen(formatContext->album));
-#endif
+ debug_msg(RELEASE, "formatContext->album=%s, strlen=%d\n", formatContext->album, strlen(formatContext->album));
}
if (trackFlags) {
readed = mmfile_read(fp, (unsigned char *)&albumbox.trackNumber, 1);
if (readed != 1) {
- debug_error("read track number fail\n");
+ debug_error(DEBUG, "read track number fail\n");
goto exception;
}
MMFILE_3GP_RATING_TAGBOX ratingTag = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "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(DEBUG, "Rating Text is NULL\n");
goto exception;
}
ratingTag.ratingInfo = mmfile_malloc(ratinginfoLen);
if (!ratingTag.ratingInfo) {
- debug_error("rating info error\n");
+ debug_error(DEBUG, "rating info error\n");
goto exception;
}
readed = mmfile_read(fp, (unsigned char *)ratingTag.ratingInfo, ratinginfoLen);
if (readed != ratinginfoLen) {
- debug_error("read rating info string fail\n");
+ debug_error(DEBUG, "read rating info string fail\n");
goto exception;
}
MMFILE_3GP_CLASSIFICATION_TAGBOX classTag = {0, };
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "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(DEBUG, "Classification Text is NULL\n");
goto exception;
}
classTag.classificationInfo = mmfile_malloc(classinfoLen);
if (!classTag.classificationInfo) {
- debug_error("class info error\n");
+ debug_error(DEBUG, "class info error\n");
goto exception;
}
readed = mmfile_read(fp, (unsigned char *)classTag.classificationInfo, classinfoLen);
if (readed != classinfoLen) {
- debug_error("read class info string fail\n");
+ debug_error(DEBUG, "read class info string fail\n");
goto exception;
}
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "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(DEBUG, "too small buffer\n");
goto exception;
}
buffer = mmfile_malloc(bufferLen);
if (!buffer) {
- debug_error("buffer malloc error\n");
+ debug_error(DEBUG, "buffer malloc error\n");
goto exception;
}
readed = mmfile_read(fp, (unsigned char *)buffer, bufferLen);
if (readed != bufferLen) {
- debug_error("read location tag fail\n");
+ debug_error(DEBUG, "read location tag fail\n");
goto exception;
}
p = buffer;
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
+ debug_msg(RELEASE, "long: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p + 0), *(p + 1), *(p + 2), *(p + 3));
+ debug_msg(RELEASE, "lati: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p + 4), *(p + 5), *(p + 6), *(p + 7));
+ debug_msg(RELEASE, "alti: 0x%02X 0x%02X 0x%02X 0x%02X \n", *(p + 8), *(p + 9), *(p + 10), *(p + 11));
ilong = mmfile_io_be_uint32(*(unsigned int *)p);
ilati = mmfile_io_be_uint32(*(unsigned int *)(p + 4));
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
+ debug_msg(RELEASE, "** Location Information **\n");
+ debug_msg(RELEASE, "Name : %s\n", lociTag.name);
+ debug_msg(RELEASE, "Role : %d (0: shooting, 1: real, 2: fictional, other: reserved)\n", lociTag.role);
+ debug_msg(RELEASE, "Longitude : %16.16f\n", lociTag.longitude);
+ debug_msg(RELEASE, "Latitude : %16.16f\n", lociTag.latitude);
+ debug_msg(RELEASE, "Altitude : %16.16f\n", lociTag.altitude);
+ debug_msg(RELEASE, "Astronomical body: %s\n", lociTag.astronomical_body);
+ debug_msg(RELEASE, "Additional notes : %s\n", lociTag.additional_notes);
formatContext->longitude = lociTag.longitude;
formatContext->latitude = lociTag.latitude;
int readed = 0;
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "read smta tag header fail\n");
goto exception;
}
smtaTag.length = mmfile_io_be_uint32(smtaTag.length);
smtaTag.value = mmfile_io_be_uint32(smtaTag.value);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Len : 0x%x", smtaTag.length);
- debug_msg("Saut : 0x%x 0x%x 0x%x 0x%x", smtaTag.saut[0], smtaTag.saut[1], smtaTag.saut[2], smtaTag.saut[3]);
- debug_msg("Value : 0x%x", smtaTag.value);
-#endif
+
+ debug_msg(RELEASE, "Len : 0x%x", smtaTag.length);
+ debug_msg(RELEASE, "Saut : 0x%x 0x%x 0x%x 0x%x", smtaTag.saut[0], smtaTag.saut[1], smtaTag.saut[2], smtaTag.saut[3]);
+ debug_msg(RELEASE, "Value : 0x%x", smtaTag.value);
if (smtaTag.saut[0] == 's'
&& smtaTag.saut[1] == 'a'
&& smtaTag.saut[2] == 'u'
&& smtaTag.saut[3] == 't') {
if (smtaTag.value == 0x01) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("This has saut tag and valid value");
-#endif
+ debug_msg(RELEASE, "This has saut tag and valid value");
formatContext->smta = 1;
} else {
- debug_error("This has saut tag and but invalid value");
+ debug_error(DEBUG, "This has saut tag and but invalid value");
goto exception;
}
} else {
- debug_error("This hasn't saut tag and valid value");
+ debug_error(DEBUG, "This hasn't saut tag and valid value");
goto exception;
}
int readed = 0;
if (!formatContext || !fp || !basic_header) {
- debug_error("invalid param\n");
+ debug_error(DEBUG, "invalid param\n");
return MMFILE_UTIL_FAIL;
}
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(DEBUG, "read cdis tag header fail\n");
goto exception;
}
value = mmfile_io_be_uint32(value);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Value : 0x%x", value);
-#endif
+ debug_msg(RELEASE, "Value : 0x%x", value);
if (value == 0x01) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("This has cdis tag and valid value");
-#endif
+ debug_msg(RELEASE, "This has cdis tag and valid value");
formatContext->cdis = 1;
} else {
- debug_error("This has cdis tag and but invalid value");
+ debug_error(DEBUG, "This has cdis tag and but invalid value");
goto exception;
}
/* meta box */
readed = mmfile_read(fp, (unsigned char *)&meta_version, 4);
if (readed != 4) {
- debug_error("read meta box version\n");
+ debug_error(DEBUG, "read meta box version\n");
goto exception;
}
/* hdlr box */
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(DEBUG, "read hdlr box header\n");
goto exception;
}
if (hdlrBoxHeader.type != FOURCC('h', 'd', 'l', 'r')) {
- debug_warning("meta type is not hdlr\n");
+ debug_warning(DEBUG, "meta type is not hdlr\n");
goto exception;
}
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(DEBUG, "read hdlr box\n");
goto exception;
}
* 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
+ debug_msg(RELEASE, "ID3v2 tag detected.\n");
id3_meta = 1;
#ifdef ENABLE_ITUNES_META
} 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
+ debug_msg(RELEASE, "Apple iTunes tag detected by mdir.\n");
#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],
+ debug_warning(DEBUG, "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]);
readed = mmfile_read(fp, read_buf, buf_size); /* to find 'ilst' */
if (readed != buf_size) {
- debug_error("read fail [%d]\n", readed);
+ debug_error(DEBUG, "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
-
+ debug_msg(RELEASE, "Apple iTunes tag detected by ilst.\n");
iTunes_meta = 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 */
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("----------------------------------- artist found, offset=[%lld], size=[%d]\n", artist_offset, artist_sz);
-#endif
+ debug_msg(RELEASE, "----------------------------------- artist found, offset=[%lld], size=[%d]\n", artist_offset, artist_sz);
}
/**
track_found = 1;
track_offset = mmfile_tell(fp);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("----------------------------------- Track found, offset=[%lld]\n", track_offset);
-#endif
+ debug_msg(RELEASE, "----------------------------------- Track found, offset=[%lld]\n", track_offset);
}
/**
genre_found = 1;
genre_offset = mmfile_tell(fp);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("----------------------------------- genre found, offset=[%lld]\n", genre_offset);
-#endif
+ debug_msg(RELEASE, "----------------------------------- genre found, offset=[%lld]\n", genre_offset);
}
#endif
cover_offset = mmfile_tell(fp);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("----------------------------------- cover_found found, offset=[%lld]\n", cover_offset);
-#endif
+ debug_msg(RELEASE, "----------------------------------- cover_found found, offset=[%lld]\n", cover_offset);
}
mmfile_seek(fp, -(_ITUNES_READ_BUF_SZ - 1), SEEK_CUR); /*FIXME: poor search*/
mmfile_seek(fp, artist_offset, SEEK_SET);
if (formatContext->artist) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("----------------------------------- previous artist was [%s] \n", formatContext->artist);
-#endif
+ debug_msg(RELEASE, "----------------------------------- previous artist was [%s] \n", formatContext->artist);
free(formatContext->artist);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("----------------------------------- new artist will be allocated with size (len+1) [%d] \n", artist_sz + 1);
-#endif
+
+ debug_msg(RELEASE, "----------------------------------- new artist will be allocated with size (len+1) [%d] \n", artist_sz + 1);
formatContext->artist = mmfile_malloc(artist_sz + 1);
if (formatContext->artist) {
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
+ debug_msg(RELEASE, "----------------------------------- new artist is [%s] \n", formatContext->artist);
if (readed != artist_sz) {
- debug_error("failed to read. ret = %d, in = %d\n", readed, artist_sz);
+ debug_error(DEBUG, "failed to read. ret = %d, in = %d\n", readed, artist_sz);
mmfile_free(formatContext->artist);
}
}
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(DEBUG, "failed to read. ret = %d, in = %d\n", readed, _ITUNES_TRACK_NUM_SZ);
} else {
track_num = mmfile_io_be_uint32(*(int *)read_buf);
if (!formatContext->tagTrackNum) {
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(DEBUG, "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
+ debug_msg(RELEASE, "genre index=[%d] \n", genre_index);
+
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
+ debug_msg(RELEASE, "genre string=[%s] \n", read_buf);
formatContext->genre = mmfile_strdup((const char *)read_buf);
}
}
/*} 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);
+ debug_warning(DEBUG, "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);
if (readed != cover_sz) {
- debug_error("failed to read. ret = %d, in = %d\n", readed, cover_sz);
+ debug_error(DEBUG, "failed to read. ret = %d, in = %d\n", readed, cover_sz);
mmfile_free(formatContext->artwork);
formatContext->artworkSize = 0;
mmfile_free(formatContext->artworkMime);
/* 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");
+ debug_error(DEBUG, "read id3v2 box header\n");
goto exception;
}
id3v2BoxHeader.type = mmfile_io_le_uint32(id3v2BoxHeader.type);
if (id3v2BoxHeader.type != FOURCC('I', 'D', '3', '2')) {
- debug_warning("meta type is not id3v2\n");
+ debug_warning(DEBUG, "meta type is not id3v2\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");
+ debug_error(DEBUG, "read id3v2 box\n");
goto exception;
}
id3v2Box.id3v2Data = mmfile_malloc(id3v2Len);
if (!id3v2Box.id3v2Data) {
- debug_error("malloc id3tag data error\n");
+ debug_error(DEBUG, "malloc id3tag data error\n");
goto exception;
}
readed = mmfile_read(fp, (unsigned char *)id3v2Box.id3v2Data, id3v2Len);
if (readed != id3v2Len) {
- debug_error("read id3tag data error\n");
+ debug_error(DEBUG, "read id3tag data error\n");
goto exception;
}
/* check id3v2 */
if (!IS_ID3V2_TAG(id3v2Box.id3v2Data)) {
- debug_error("it is not id3tag\n");
+ debug_error(DEBUG, "it is not id3tag\n");
goto exception;
}
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");
+ debug_error(DEBUG, "it is not valid id3tag\n");
goto exception;
}
tagVersion = id3v2Box.id3v2Data[3];
if (tagVersion > 4) {
- debug_error("tag vesion is too high\n");
+ debug_error(DEBUG, "tag vesion is too high\n");
goto exception;
}
}
case 1:
default: {
- debug_error("tag vesion is not support\n");
+ debug_error(DEBUG, "tag vesion is not support\n");
versionCheck = false;
break;
}
}
if (versionCheck == false) {
- debug_error("tag parsing is fail\n");
+ debug_error(DEBUG, "tag parsing is fail\n");
goto exception;
}
ret = mmfile_open(&fp, formatContext->uriFileName, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
basic_header.type = mmfile_io_le_uint32(basic_header.type);
if (basic_header.size == 0) {
- debug_warning("header is invalid.\n");
+ debug_warning(DEBUG, "header is invalid.\n");
basic_header.size = readed;
basic_header.type = 0;
chunk_size = basic_header.size;
switch (basic_header.type) {
case FOURCC('m', 'o', 'o', 'v'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [moov] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [moov] SIZE: [%lld]Byte\n", chunk_size);
break;
}
case FOURCC('u', 'd', 't', 'a'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [udat] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [udat] SIZE: [%lld]Byte\n", chunk_size);
break;
}
/*/////////////////////////////////////////////////////////////// */
/* Extracting Tag Data // */
/*/////////////////////////////////////////////////////////////// */
case FOURCC('t', 'i', 't', 'l'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [titl] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [titl] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [dscp] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [cprt] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [perf] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [auth] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [gnre] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [albm] SIZE: [%lld]Byte\n", chunk_size);
GetAlbumFromAlbumTagBox(formatContext, fp, &basic_header);
break;
}
case FOURCC('y', 'r', 'r', 'c'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [yrrc] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [yrrc] SIZE: [%lld]Byte\n", chunk_size);
GetYearFromYearTagBox(formatContext, fp, &basic_header);
break;
}
case FOURCC('r', 't', 'n', 'g'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [rtng] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [rtng] SIZE: [%lld]Byte\n", chunk_size);
GetRatingFromRatingTagBox(formatContext, fp, &basic_header); /* not use */
break;
}
case FOURCC('c', 'l', 's', 'f'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [clsf] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [clsf] SIZE: [%lld]Byte\n", chunk_size);
GetClassficationFromClsfTagBox(formatContext, fp, &basic_header);
break;
}
case FOURCC('k', 'y', 'w', 'd'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [kywd] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [kywd] SIZE: [%lld]Byte\n", chunk_size);
ret = mmfile_seek(fp, basic_header.start_offset + chunk_size, SEEK_SET);
break;
}
case FOURCC('l', 'o', 'c', 'i'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [loci] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [loci] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [smta] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [smta] SIZE: [%lld]Byte\n", chunk_size);
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: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [meta] SIZE: [%lld]Byte\n", chunk_size);
GetTagFromMetaBox(formatContext, fp, &basic_header);
break;
}
case FOURCC('t', 'r', 'a', 'k'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [trak] SIZE: [%lld]Byte\n", chunk_size);
-#endif
+ debug_msg(RELEASE, "MPEG4: [trak] SIZE: [%lld]Byte\n", chunk_size);
break;
}
case FOURCC('u', 'u', 'i', 'd'): {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MPEG4: [uuid] SIZE: [%lld]Byte\n", chunk_size);
-#endif
unsigned long uuid[4] = {0, };
+ debug_msg(RELEASE, "MPEG4: [uuid] SIZE: [%lld]Byte\n", chunk_size);
+
mmfile_read(fp, (unsigned char *)uuid, sizeof(uuid));
if (mmfile_io_be_uint32(uuid[0]) == 0xffcc8263
break;
}
default: {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("4CC: Not Support [%c%c%c%c]. So skip it. Size [%lld Byte]\n",
+ debug_msg(RELEASE, "4CC: Not Support [%c%c%c%c]. So skip it. Size [%lld Byte]\n",
((char *)&basic_header.type)[0], ((char *)&basic_header.type)[1],
((char *)&basic_header.type)[2], ((char *)&basic_header.type)[3], chunk_size);
-#endif
ret = mmfile_seek(fp, basic_header.start_offset + chunk_size, SEEK_SET);
break;
}
}
if (ret == MMFILE_UTIL_FAIL) {
- debug_error("mmfile operation is error\n");
+ debug_error(DEBUG, "mmfile operation is error\n");
ret = -1;
goto exit;
}
*charset_array = calloc(AV_ID3V2_MAX, sizeof(char *));
if (*charset_array == NULL) {
- debug_error("calloc failed ");
+ debug_error(DEBUG, "calloc failed ");
if (locale != NULL)
free(locale);
return false;
if (locale != NULL) {
(*charset_array)[AV_ID3V2_ISO_8859] = strdup(locale);
} else {
- debug_error("get locale failed");
+ debug_error(DEBUG, "get locale failed");
(*charset_array)[AV_ID3V2_ISO_8859] = NULL;
}
const char *locale = MMFileUtilGetLocale(NULL);
char *pFullStr = NULL;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("ID3tag v110--------------------------------------------------------------\n");
-#endif
+ debug_msg(RELEASE, "ID3tag v110--------------------------------------------------------------\n");
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);
free(pFullStr);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pTitle returned =(%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pTitle returned =(%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
}
if (pInfo->tagV2Info.bArtistMarked == false) {
free(pFullStr);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pArtist returned =(%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pArtist returned =(%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
}
if (pInfo->tagV2Info.bAlbumMarked == false) {
free(pFullStr);
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pAlbum returned =(%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pAlbum returned =(%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
}
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
+
+ debug_msg(RELEASE, "pInfo->pYear returned =(%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
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
+ debug_msg(RELEASE, "pInfo->pYear returned =(%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
}
}
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
+ debug_msg(RELEASE, "pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
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
+ debug_msg(RELEASE, "pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
}
}
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
+
+ debug_msg(RELEASE, "pInfo->pTrackNum returned =(%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
}
}
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
+ debug_msg(RELEASE, "pInfo->genre returned genre number (%d)\n", pInfo->genre);
}
return true;
needToloopv2taglen = taglen - MP3_TAGv2_HEADER_LEN;
curPos = MP3_TAGv2_HEADER_LEN;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("ID3tag v222--------------------------------------------------------------\n");
-#endif
+ debug_msg(RELEASE, "ID3tag v222--------------------------------------------------------------\n");
+
if (needToloopv2taglen - MP3_TAGv2_22_TXT_HEADER_LEN > MP3_TAGv2_22_TXT_HEADER_LEN) {
v2numOfFrames = 1;
while (needToloopv2taglen > MP3_TAGv2_22_TXT_HEADER_LEN) {
pExtContent = mmfile_malloc(realCpyFrameNum + 3);
if (pExtContent == NULL) {
- debug_error("out of memory for pExtContent\n");
+ debug_error(DEBUG, "out of memory for pExtContent\n");
continue;
}
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
+ debug_msg(RELEASE, "pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
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
+ debug_msg(RELEASE, "pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
pInfo->tagV2Info.bYearMarked = true;
} else if (strncmp((char *)CompTmp, "COM", 3) == 0 && pInfo->tagV2Info.bDescriptionMarked == false) {
/*skip language data! */
textEncodingType = AV_ID3V2_UTF16;
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
+ debug_msg(RELEASE, "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
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
+ debug_msg(RELEASE, "mmf_file_id3tag_parse_v222: failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("mmf_file_id3tag_parse_v222: Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "mmf_file_id3tag_parse_v222: Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
}
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
if ((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
bool ret = FALSE;
if (ret == TRUE) {
sscanf(pInfo->pGenre, "%d", &int_genre);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("genre information is inteager [%d]\n", int_genre);
-#endif
+ debug_msg(RELEASE, "genre information is inteager [%d]\n", int_genre);
/*Change int to string */
if ((0 <= int_genre) && (int_genre < GENRE_COUNT - 1)) {
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
pInfo->tagV2Info.bEncByMarked = true;
} else if (strncmp((char *)CompTmp, "WXX", 3) == 0 && pInfo->tagV2Info.bURLMarked == false) {
if (realCpyFrameNum > 4) {
textEncodingType = AV_ID3V2_UTF16;
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
+ debug_msg(RELEASE, "pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
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
+ debug_msg(RELEASE, "mmf_file_id3tag_parse_v222: failed to get URL Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("mmf_file_id3tag_parse_v222: URL info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "mmf_file_id3tag_parse_v222: URL info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
}
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
pInfo->tagV2Info.bRecDateMarked = true;
} else if (strncmp((char *)CompTmp, "PIC", 3) == 0 && pInfo->tagV2Info.bImageMarked == false && realCpyFrameNum <= 2000000) {
if (pExtContent[0] != 0) {
checkImgExtMax++;
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("mmf_file_id3tag_parse_v222: PIC image's not included to image Extention\n");
-#endif
+ debug_msg(RELEASE, "mmf_file_id3tag_parse_v222: PIC image's not included to image Extention\n");
}
imgstartOffset += checkImgExtMax;
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);
+ debug_error(DEBUG, "End of APIC Tag %d %d %d\n", realCpyFrameNum, imgstartOffset, cur_pos);
break;
}
/*check end of image description*/
if ((pExtContent[imgstartOffset + cur_pos + 1] == gTagJPEGHeader[0]) ||
(pExtContent[imgstartOffset + cur_pos + 1] == gTagPNGHeader[0])) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("length of description (%d)", cur_pos);
-#endif
-
+ debug_msg(RELEASE, "length of description (%d)", cur_pos);
break;
}
}
/*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
+ debug_msg(RELEASE, "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
pInfo->imageInfo.imgDesLen = new_dis_len; /**/
}
imgstartOffset++;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
-#endif
+ debug_msg(RELEASE, "after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
if (realCpyFrameNum - imgstartOffset > 0) {
pInfo->imageInfo.imageLen = realCpyFrameNum - imgstartOffset;
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
+ debug_msg(RELEASE, "No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
}
}
needToloopv2taglen = taglen - MP3_TAGv2_HEADER_LEN;
curPos = MP3_TAGv2_HEADER_LEN;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("ID3tag v223--------------------------------------------------------------\n");
-#endif
+ debug_msg(RELEASE, "ID3tag v223--------------------------------------------------------------\n");
/* check Extended Header */
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
+ debug_msg(RELEASE, "--------------- extendedHeaderLen = %d\n", extendedHeaderLen);
if (extendedHeaderLen > (int)(taglen - curPos)) {
- debug_error("extended header too long.\n");
+ debug_error(DEBUG, "extended header too long.\n");
} else {
curPos += extendedHeaderLen;
curPos += 4;
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
+ debug_msg(RELEASE, "----------------------------------------------------------------------------------------------------\n");
if (oneFrameLen > taglen - curPos)
break;
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
+ debug_msg(RELEASE, "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
textEncodingType = AV_ID3V2_UTF16;
} 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
+ debug_msg(RELEASE, "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
textEncodingType = AV_ID3V2_UTF16_BE;
} 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
+ debug_msg(RELEASE, "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
textEncodingType = AV_ID3V2_UTF16;
} 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
+ debug_msg(RELEASE, "this text string(%s) encoded by UTF16 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
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
-
+ debug_msg(RELEASE, "encodingOffset will be set to 1\n");
encodingOffSet = 1;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Finding encodingOffset\n");
-#endif
+ debug_msg(RELEASE, "Finding encodingOffset\n");
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
+ debug_msg(RELEASE, "this text string(%s) encoded by ISO-8859-1 encodingOffSet(%d)\n", CompTmp, encodingOffSet);
}
if (encodingOffSet < purelyFramelen) {
pExtContent = mmfile_malloc(realCpyFrameNum + 3);
if (pExtContent == NULL) {
- debug_msg("pExtContent malloc failed\n");
+ debug_msg(DEBUG, "pExtContent malloc failed\n");
continue;
}
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
+ debug_msg(RELEASE, "get the new text ecoding type\n");
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(DEBUG, "WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char *)CompTmp);
continue;
}
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
+ debug_msg(RELEASE, "pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
pInfo->tagV2Info.bYearMarked = true;
} else if (strncmp((char *)CompTmp, "COMM", 4) == 0 && pInfo->tagV2Info.bDescriptionMarked == false) {
if (realCpyFrameNum > 3) {
tmp += 3;
textEncodingType = AV_ID3V2_UTF16_BE;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pComment Never Get Here!!\n");
-#endif
+ debug_msg(RELEASE, "pInfo->pComment Never Get Here!!\n");
}
} else {
while ((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
textEncodingType = AV_ID3V2_ISO_8859;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
-#endif
-
+ debug_msg(RELEASE, "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
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
+ debug_msg(RELEASE, "failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
pInfo->commentLen = 0;
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
pInfo->commentLen = 0;
}
tmp = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
pInfo->tagV2Info.bDescriptionMarked = true;
} else if (strncmp((char *)CompTmp, "SYLT", 4) == 0 && pInfo->tagV2Info.bSyncLyricsMarked == false) {
int idx = 0;
tmp += 3;
textEncodingType = AV_ID3V2_UTF16_BE;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pSyncLyrics Never Get Here!!\n");
-#endif
+ debug_msg(RELEASE, "pInfo->pSyncLyrics Never Get Here!!\n");
}
} else {
while ((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
textEncodingType = AV_ID3V2_ISO_8859;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
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
+ debug_msg(RELEASE, "failed to get Synchronised lyrics Info realCpyFramNum(%d)\n", realCpyFrameNum);
pInfo->syncLyricsNum = 0;
} else {
if (textEncodingType == AV_ID3V2_UTF16) {
- debug_warning("[AV_ID3V2_UTF16] not implemented\n");
+ debug_warning(DEBUG, "[AV_ID3V2_UTF16] not implemented\n");
} else if (textEncodingType == AV_ID3V2_UTF16_BE) {
- debug_warning("[AV_ID3V2_UTF16_BE] not implemented\n");
+ debug_warning(DEBUG, "[AV_ID3V2_UTF16_BE] not implemented\n");
} else {
for (idx = 0; idx < realCpyFrameNum; idx++) {
if (pExtContent[tmp + idx] == 0x00) {
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__
- 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
+ debug_msg(RELEASE, "[%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);
copy_len = 0;
synclyrics_info_list = g_list_append(synclyrics_info_list, synclyrics_info);
}
}
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("failed to get Synchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
-#endif
+ debug_msg(RELEASE, "failed to get Synchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
pInfo->syncLyricsNum = 0;
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Synchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "Synchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
pInfo->syncLyricsNum = 0;
}
tmp = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pSyncLyrics returned = (%s), pInfo->syncLyricsNum(%d)\n", pInfo->pSyncLyrics, pInfo->syncLyricsNum);
-#endif
+ debug_msg(RELEASE, "pInfo->pSyncLyrics returned = (%s), pInfo->syncLyricsNum(%d)\n", pInfo->pSyncLyrics, pInfo->syncLyricsNum);
pInfo->tagV2Info.bSyncLyricsMarked = true;
} else if (strncmp((char *)CompTmp, "USLT", 4) == 0 && pInfo->tagV2Info.bUnsyncLyricsMarked == false) {
char *lang_info = strndup((char *)pExtContent, 3);
}
/*pExtContent[tmp+1] value should't have encoding value */
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tpExtContent[%d] %x\n", tmp, pExtContent[tmp]);
-#endif
+ debug_msg(RELEASE, "tpExtContent[%d] %x\n", tmp, pExtContent[tmp]);
+
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) {
tmp += 3;
textEncodingType = AV_ID3V2_UTF16_BE;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pUnsyncLyrics Never Get Here!!\n");
-#endif
+ debug_msg(RELEASE, "pInfo->pUnsyncLyrics Never Get Here!!\n");
}
} else {
while ((pExtContent[tmp] < 0x20) && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
textEncodingType = AV_ID3V2_ISO_8859;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
-#endif
-
char *char_set = NULL;
+
+ debug_msg(RELEASE, "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
+
if (textEncodingType == AV_ID3V2_ISO_8859) {
if (lang_info != NULL && !strcasecmp(lang_info, "KOR")) {
char_set = strdup("EUC-KR");
_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
+ debug_msg(RELEASE, "failed to get Unsynchronised lyrics Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
pInfo->unsynclyricsLen = 0;
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Unsynchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "Unsynchronised lyrics too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
pInfo->unsynclyricsLen = 0;
}
tmp = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
if ((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
bool ret = FALSE;
if (ret == TRUE) {
sscanf(pInfo->pGenre, "%d", &int_genre);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("genre information is inteager [%d]\n", int_genre);
-#endif
+ debug_msg(RELEASE, "genre information is inteager [%d]\n", int_genre);
/*Change int to string */
if ((0 <= int_genre) && (int_genre < GENRE_COUNT - 1)) {
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pComposer returned = (%s), pInfo->composerLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pComposer returned = (%s), pInfo->composerLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
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);
-
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
-#endif
+ debug_msg(RELEASE, "pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
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);
+ debug_msg(DEBUG, "text encoding %d \n", textEncodingType);
if (pExtContent[0] != '\0') {
for (inx = 0; inx < MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH - 1; inx++)
pInfo->imageInfo.imgMimetypeLen = checkImgMimeTypeMax;
} else {
pInfo->imageInfo.imgMimetypeLen = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("APIC image's not included to MIME type\n");
-#endif
- }
+ debug_msg(RELEASE, "APIC image's not included to MIME type\n");
+ }
imgstartOffset += checkImgMimeTypeMax;
if (strncmp(pInfo->imageInfo.imageMIMEType, MIME_PRFIX, strlen(MIME_PRFIX)) != 0) {
pInfo->imageInfo.imgMimetypeLen = 0;
- debug_error("APIC NOT VALID");
+ debug_error(DEBUG, "APIC NOT VALID");
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
+ debug_msg(RELEASE, "after scaning Mime type imgstartOffset(%d) value!\n", imgstartOffset);
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
- }
+ debug_msg(RELEASE, "APIC image has invalid picture type(0x%x)\n", pExtContent[imgstartOffset]);
+ }
imgstartOffset++;/*PictureType(1byte) */
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("after scaning PictureType imgstartOffset(%d) value!\n", imgstartOffset);
-#endif
+ debug_msg(RELEASE, "after scaning PictureType imgstartOffset(%d) value!\n", imgstartOffset);
if (pExtContent[imgstartOffset] != 0x0) {
int cur_pos = 0;
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);
+ debug_error(DEBUG, "End of APIC Tag %d %d %d\n", realCpyFrameNum, imgstartOffset, cur_pos);
break;
}
/*check end of image description*/
if ((pExtContent[imgstartOffset + cur_pos + 1] == gTagJPEGHeader[0]) ||
(pExtContent[imgstartOffset + cur_pos + 1] == gTagPNGHeader[0])) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("length of description (%d)", cur_pos);
-#endif
-
- break;
+ debug_msg(RELEASE, "length of description (%d)", cur_pos);
+ break;
}
}
cur_pos++;
/*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
- mmfile_free(tmp_desc);
+ debug_msg(RELEASE, "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
+ 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
- }
+ debug_msg(RELEASE, "APIC image's not included to Description!!!\n");
+ }
if ((pExtContent[imgstartOffset] == '\0') && (realCpyFrameNum - imgstartOffset > 0)) {
imgstartOffset++; /* endofDesceriptionType(1byte) */
imgstartOffset++;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
-#endif
+ debug_msg(RELEASE, "after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
if (realCpyFrameNum - imgstartOffset > 0) {
pInfo->imageInfo.imageLen = realCpyFrameNum - imgstartOffset;
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",
+ debug_msg(RELEASE, "No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
+ }
+ debug_msg(RELEASE, "pInfo->imageInfo.imageLen(%d), imgstartOffset(%d)!\n", pInfo->imageInfo.imageLen, imgstartOffset);
+ } else {
+ debug_msg(RELEASE, "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",
+ debug_msg(RELEASE, "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;
pInfo->tagV2Info.bImageMarked = true;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
-#endif
- }
+ debug_msg(RELEASE, "CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
+ }
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("All of the pExtContent Values are NULL\n");
-#endif
- }
+ debug_msg(RELEASE, "All of the pExtContent Values are NULL\n");
+ }
} else {
curPos += purelyFramelen;
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
- }
+
+ debug_msg(RELEASE, "This Frame's size is Zero! purelyFramelen(%d)\n", purelyFramelen);
+ }
if (pExtContent) _FREE_EX(pExtContent);
memset(CompTmp, 0, 4);
needToloopv2taglen = taglen - MP3_TAGv2_HEADER_LEN;
curPos = MP3_TAGv2_HEADER_LEN;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("ID3tag v224--------------------------------------------------------------\n");
-#endif
+ debug_msg(RELEASE, "ID3tag v224--------------------------------------------------------------\n");
/* check Extended Header */
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
+ debug_msg(RELEASE, "--------------- extendedHeaderLen = %d\n", extendedHeaderLen);
if (extendedHeaderLen > (int)(taglen - curPos)) {
- debug_error("extended header too long.\n");
+ debug_error(DEBUG, "extended header too long.\n");
} else {
curPos += extendedHeaderLen;
}
purelyFramelen = oneFrameLen - MP3_TAGv2_23_TXT_HEADER_LEN;
curPos += MP3_TAGv2_23_TXT_HEADER_LEN;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("-----------------------------------------------------------------------------------\n");
-#endif
+ debug_msg(RELEASE, "-----------------------------------------------------------------------------------\n");
if (oneFrameLen > MP3_TAGv2_23_TXT_HEADER_LEN && purelyFramelen <= taglen - curPos) {
curPos += purelyFramelen;
pExtContent = mmfile_malloc(realCpyFrameNum + 3);
if (pExtContent == NULL) {
- debug_error("out of memoryu for id3tag parse\n");
+ debug_error(DEBUG, "out of memoryu for id3tag parse\n");
continue;
}
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];
+ debug_msg(RELEASE, "get the new text ecoding type\n");
+ 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(DEBUG, "WRONG ENCOIDNG TYPE [%d], FRAME[%s]\n", textEncodingType, (char *)CompTmp);
continue;
}
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;
+ debug_msg(RELEASE, "pInfo->pTitle returned = (%s), pInfo->titleLen(%d)\n", pInfo->pTitle, pInfo->titleLen);
+ pInfo->tagV2Info.bTitleMarked = true;
} else if (strncmp((char *)CompTmp, "TPE1", 4) == 0 && pInfo->tagV2Info.bArtistMarked == false) {
if (textEncodingType == AV_ID3V2_UTF8) {
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
- pInfo->tagV2Info.bArtistMarked = true;
+
+ debug_msg(RELEASE, "pInfo->pArtist returned = (%s), pInfo->artistLen(%d)\n", pInfo->pArtist, pInfo->artistLen);
+ 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 */
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
- pInfo->tagV2Info.bAlbum_ArtistMarked = true;
+ debug_msg(RELEASE, "pInfo->pAlbum_Artist returned = (%s), pInfo->album_artistLen(%d)\n", pInfo->pAlbum_Artist, pInfo->album_artistLen);
+ 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 */
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
- pInfo->tagV2Info.bConductorMarked = true;
+ debug_msg(RELEASE, "pInfo->pConductor returned = (%s), pInfo->conductorLen(%d)\n", pInfo->pConductor, pInfo->conductorLen);
+ 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 */
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
- pInfo->tagV2Info.bAlbumMarked = true;
+ debug_msg(RELEASE, "pInfo->pAlbum returned = (%s), pInfo->albumLen(%d)\n", pInfo->pAlbum, pInfo->albumLen);
+ 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 */
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
- pInfo->tagV2Info.bYearMarked = true;
+ debug_msg(RELEASE, "pInfo->pYear returned = (%s), pInfo->yearLen(%d)\n", pInfo->pYear, pInfo->yearLen);
+ pInfo->tagV2Info.bYearMarked = true;
} else if (strncmp((char *)CompTmp, "COMM", 4) == 0 && pInfo->tagV2Info.bDescriptionMarked == false) {
if (realCpyFrameNum > 3) {
realCpyFrameNum -= 3;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pComment Never Get Here!!\n");
-#endif
- }
+ debug_msg(RELEASE, "pInfo->pComment Never Get Here!!\n");
+ }
} else if (textEncodingType == AV_ID3V2_UTF8) {
while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
realCpyFrameNum--;
textEncodingType = AV_ID3V2_ISO_8859;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
if (textEncodingType == AV_ID3V2_UTF8) {
pInfo->pComment = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
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
- }
+ debug_msg(RELEASE, "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+ }
tmp = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
-#endif
- pInfo->tagV2Info.bDescriptionMarked = true;
+ debug_msg(RELEASE, "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
+ pInfo->tagV2Info.bDescriptionMarked = true;
} else if (strncmp((char *)CompTmp, "SYLT", 4) == 0 && pInfo->tagV2Info.bSyncLyricsMarked == false) {
int idx = 0;
int copy_len = 0;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pSyncLyrics Never Get Here!!\n");
-#endif
- }
+ debug_msg(RELEASE, "pInfo->pSyncLyrics Never Get Here!!\n");
+ }
} else if (textEncodingType == AV_ID3V2_UTF8) {
while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
realCpyFrameNum--;
textEncodingType = AV_ID3V2_ISO_8859;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
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;
+ debug_msg(RELEASE, "failed to get Synchronised lyrics Info realCpyFramNum(%d)\n", realCpyFrameNum);
+ pInfo->syncLyricsNum = 0;
} else {
if (textEncodingType == AV_ID3V2_UTF16) {
- debug_warning("[AV_ID3V2_UTF16] not implemented\n");
+ debug_warning(DEBUG, "[AV_ID3V2_UTF16] not implemented\n");
} else if (textEncodingType == AV_ID3V2_UTF16_BE) {
- debug_warning("[AV_ID3V2_UTF16_BE] not implemented\n");
+ debug_warning(DEBUG, "[AV_ID3V2_UTF16_BE] not implemented\n");
} else {
for (idx = 0; idx < realCpyFrameNum; idx++) {
if (pExtContent[tmp + idx] == 0x00) {
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__
- 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
- copy_len = 0;
+ debug_msg(RELEASE, "[%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);
+ copy_len = 0;
synclyrics_info_list = g_list_append(synclyrics_info_list, synclyrics_info);
}
copy_len++;
}
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("SyncLyrics info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
-#endif
- }
+ debug_msg(RELEASE, "SyncLyrics info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+ }
tmp = 0;
pInfo->tagV2Info.bSyncLyricsMarked = true;
tmp += 2;
textEncodingType = AV_ID3V2_UTF16;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pUnsyncLyrics Never Get Here!!\n");
-#endif
- }
+ debug_msg(RELEASE, "pInfo->pUnsyncLyrics Never Get Here!!\n");
+ }
} else if (textEncodingType == AV_ID3V2_UTF8) {
while (pExtContent[tmp] < 0x20 && (tmp < realCpyFrameNum)) { /* text string encoded by ISO-8859-1 */
realCpyFrameNum--;
textEncodingType = AV_ID3V2_ISO_8859;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
-#endif
+ debug_msg(RELEASE, "tmp(%d) textEncodingType(%d), realCpyFrameNum(%d)\n", tmp, textEncodingType, realCpyFrameNum);
if (textEncodingType == AV_ID3V2_UTF8) {
pInfo->pUnsyncLyrics = mmfile_malloc(realCpyFrameNum + 2); /*Ignore NULL char for UTF16 */
pInfo->unsynclyricsLen = realCpyFrameNum;
_STRNCPY_EX(pInfo->pUnsyncLyrics, pExtContent, pInfo->unsynclyricsLen);
} else {
- debug_error("out of memoryu for SyncLyrics\n");
+ debug_error(DEBUG, "out of memoryu for SyncLyrics\n");
}
} 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
- }
+ debug_msg(RELEASE, "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
+ }
tmp = 0;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
-#endif
- pInfo->tagV2Info.bDescriptionMarked = true;
+ debug_msg(RELEASE, "pInfo->pUnsyncLyrics returned = (%s), pInfo->unsynclyricsLen(%d)\n", pInfo->pUnsyncLyrics, pInfo->unsynclyricsLen);
+ 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 */
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
+ debug_msg(RELEASE, "pInfo->pGenre returned = (%s), pInfo->genreLen(%d)\n", pInfo->pGenre, pInfo->genreLen);
if ((pInfo->pGenre != NULL) && (pInfo->genreLen > 0)) {
bool ret = FALSE;
if (ret == TRUE) {
sscanf(pInfo->pGenre, "%d", &int_genre);
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("genre information is inteager [%d]\n", int_genre);
-#endif
+ debug_msg(RELEASE, "genre information is inteager [%d]\n", int_genre);
/*Change int to string */
if ((0 <= int_genre) && (int_genre < GENRE_COUNT - 1)) {
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
- pInfo->tagV2Info.bTrackNumMarked = true;
+ debug_msg(RELEASE, "pInfo->pTrackNum returned = (%s), pInfo->tracknumLen(%d)\n", pInfo->pTrackNum, pInfo->tracknumLen);
+ 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 */
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
- pInfo->tagV2Info.bEncByMarked = true;
+ debug_msg(RELEASE, "pInfo->pEncBy returned = (%s), pInfo->encbyLen(%d)\n", pInfo->pEncBy, pInfo->encbyLen);
+ 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 */
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
- pInfo->tagV2Info.bURLMarked = true;
+ debug_msg(RELEASE, "pInfo->pURL returned = (%s), pInfo->urlLen(%d)\n", pInfo->pURL, pInfo->urlLen);
+ 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 */
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
- pInfo->tagV2Info.bCopyRightMarked = true;
+ debug_msg(RELEASE, "pInfo->pCopyright returned = (%s), pInfo->copyrightLen(%d)\n", pInfo->pCopyright, pInfo->copyrightLen);
+ 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 */
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
- pInfo->tagV2Info.bOriginArtistMarked = true;
+ debug_msg(RELEASE, "pInfo->pOriginArtist returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pOriginArtist, pInfo->originartistLen);
+ 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 */
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
- pInfo->tagV2Info.bComposerMarked = true;
+ debug_msg(RELEASE, "pInfo->pComposer returned = (%s), pInfo->originartistLen(%d)\n", pInfo->pComposer, pInfo->composerLen);
+ 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 */
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
- pInfo->tagV2Info.bRecDateMarked = true;
+ debug_msg(RELEASE, "pInfo->pRecDate returned = (%s), pInfo->recdateLen(%d)\n", pInfo->pRecDate, pInfo->recdateLen);
+ 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 {
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
- pInfo->tagV2Info.bContentGroupMarked = true;
+
+ debug_msg(RELEASE, "pInfo->pContentGroup returned = (%s), pInfo->contentGroupLen(%d)\n", pInfo->pContentGroup, pInfo->contentGroupLen);
+ 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++)
if (strncmp(pInfo->imageInfo.imageMIMEType, MIME_PRFIX, strlen(MIME_PRFIX)) != 0) {
pInfo->imageInfo.imgMimetypeLen = 0;
- debug_error("APIC NOT VALID");
+ debug_error(DEBUG, "APIC NOT VALID");
continue;
}
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);
+ debug_error(DEBUG, "End of APIC Tag %d %d %d\n", realCpyFrameNum, imgstartOffset, cur_pos);
break;
}
/*check end of image description*/
if ((pExtContent[imgstartOffset + cur_pos + 1] == gTagJPEGHeader[0]) ||
(pExtContent[imgstartOffset + cur_pos + 1] == gTagPNGHeader[0])) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("length of description (%d)", cur_pos);
-#endif
-
- break;
+ debug_msg(RELEASE, "length of description (%d)", cur_pos);
+ break;
}
}
cur_pos++;
if (tmp_desc != NULL) {
memcpy(tmp_desc, pExtContent + imgstartOffset, dis_len);
- debug_msg("tmp_desc %s\n", tmp_desc);
+ debug_msg(DEBUG, "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);
+ debug_msg(DEBUG, "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, new_dis_len);
mmfile_free(tmp_desc);
pInfo->imageInfo.imgDesLen = new_dis_len; /**/
imgstartOffset++;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
-#endif
+ debug_msg(RELEASE, "after scaning imgDescription imgstartOffset(%d) value!\n", imgstartOffset);
if (realCpyFrameNum - imgstartOffset > 0) {
pInfo->imageInfo.imageLen = realCpyFrameNum - imgstartOffset;
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
- }
+ debug_msg(RELEASE, "No APIC image!! realCpyFrameNum(%d) - imgstartOffset(%d)\n", realCpyFrameNum, imgstartOffset);
+ }
}
}
imgstartOffset = 0;
pInfo->tagV2Info.bImageMarked = true;
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
-#endif
- }
+ debug_msg(RELEASE, "CompTmp(%s) This Frame ID currently not Supports!!\n", CompTmp);
+ }
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("mmf_file_id3tag_parse_v224: All of the pExtContent Values are NULL\n");
-#endif
- }
+ debug_msg(RELEASE, "mmf_file_id3tag_parse_v224: All of the pExtContent Values are NULL\n");
+ }
} else {
curPos += purelyFramelen;
/* 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)
+ debug_msg(RELEASE, "Genre: %d\n", genre);
+
+ if (genre > 147)
genre = 148;
if (MpegAudio_Genre[genre] != NULL) {
}
}
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Genre was not Found.\n");
-#endif
- }
+ debug_msg(RELEASE, "Genre was not Found.\n");
+ }
} else if (pInfo->tagV2Info.bGenreMarked == true) {
if (pInfo->genreLen && pInfo->tagV2Info.bGenreUTF16) {
pInfo->pGenre[pInfo->genreLen + 1] = '\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
- if (pInfo->pGenre) {
+ debug_msg(RELEASE, "pInfo->genreLen size is Zero Or not UTF16 code! genreLen[%d] genre[%s]\n", pInfo->genreLen, pInfo->pGenre);
+
+ if (pInfo->pGenre) {
pInfo->genreLen = strlen(pInfo->pGenre);
mpegAudioGenre = mmfile_malloc(sizeof(char) * (pInfo->genreLen + 1));
if (mpegAudioGenre != NULL) {
}
}
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("pInfo->pGenre = %s\n", pInfo->pGenre);
-#endif
- } else if (bAdditionGenre == false && pInfo->genreLen > 0) {
+ debug_msg(RELEASE, "pInfo->pGenre = %s\n", pInfo->pGenre);
+ } else if (bAdditionGenre == false && pInfo->genreLen > 0) {
/**
* Genre string.
*/
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
- }
+ debug_msg(RELEASE, "pInfo->pGenre = %s, pInfo->genreLen = %d\n", pInfo->pGenre, pInfo->genreLen);
+ } else {
+ debug_msg(RELEASE, "Failed to \"(...)\" value to genre = %s\n", pInfo->pGenre);
+ }
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("mpegAudioGenre = %x\n", mpegAudioGenre);
-#endif
- }
+ debug_msg(RELEASE, "mpegAudioGenre = %x\n", 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
- }
+ debug_msg(RELEASE, "Neither ID3 v1 nor v2 info doesn't have Genre Info.\n");
+ }
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
mmfile_seek(fp, 0L, MMFILE_SEEK_SET);
if (filesize < _MMFILE_MP3_HEADER_LENGTH) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
ret = 0;
goto exit;
}
/* Search the existance of ID3 tag */
ret = _MMFileSearchID3Tag(fp, &sizeID3);
if (ret == 0) {
- debug_error("Error in searching the ID3 tag\n");
+ debug_error(RELEASE, "Error in searching the ID3 tag\n");
/* goto exit; */
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
break;
}
}
if ((j + frameSize) >= (readed - _MMFILE_MP3_HEADER_LENGTH)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("MP3 coner hit %d %d\n", j, frameSize);
-#endif
- break;
+ debug_msg(RELEASE, "MP3 coner hit %d %d\n", j, frameSize);
+ break;
}
frameSize = _MMFileIsMP3Header(buffer + j + frameSize);
count++;
if (count == frameCnt) {
ret = 1;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected at %d\n", i + j);
-#endif
- goto exit;
+ debug_msg(RELEASE, "Header Detected at %d\n", i + j);
+ goto exit;
}
} else {
offset = 1;
}
failMP3:
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Not Detected at: %d\n", i + j);
-#endif
-exit:
+ debug_msg(RELEASE, "Header Not Detected at: %d\n", i + j);
+ exit:
if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_AAC_HEADER_LENGTH) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
ret = 0;
goto exit;
}
/* Search the existance of ID3 tag */
ret = _MMFileSearchID3Tag(fp, &sizeID3);
if (ret == 0) {
- debug_error("Error in searching the ID3 tag\n");
+ debug_error(RELEASE, "Error in searching the ID3 tag\n");
/* goto exit; */
}
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(RELEASE, "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++) {
+ debug_msg(RELEASE, "read error. size = %d. i = %d\n", readed, i);
+
+ for (j = 0; (j < readed - _MMFILE_AAC_HEADER_LENGTH); j++) {
sync = ((buffer[j] << 8) | (buffer[j + 1]));
goto fail;
}
if ((j + frameSize) >= (readed - 2)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("AAC coner hit %d %d\n", j, frameSize);
-#endif
- break;
+ debug_msg(RELEASE, "AAC coner hit %d %d\n", j, frameSize);
+ break;
}
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
- goto exit;
+ debug_msg(RELEASE, "AAC ADTS Header Detected at %d\n", i + j);
+ goto exit;
}
} 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
- goto exit;
+ debug_msg(RELEASE, "AAC ADIF Header Detected at %d\n", i + j);
+ goto exit;
}
}
/*If j is zero, this loop is infinite */
fail:
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected Failed\n");
-#endif
-
+ debug_msg(RELEASE, "Header Detected Failed\n");
exit:
if (pFileIO == NULL && fp != NULL)
mmfile_close(fp);
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
ret = 0;
goto exit;
}
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_OGG_HEADER_LENGTH) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
ret = 0;
goto exit;
}
/* Search the existance of ID3 tag */
ret = _MMFileSearchID3Tag(fp, &sizeID3);
if (ret == 0) {
- debug_error("Error in searching the ID3 tag\n");
+ debug_error(RELEASE, "Error in searching the ID3 tag\n");
/* goto exit; */
}
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(RELEASE, "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)) {
ret = 1;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected at %d\n", i + j);
-#endif
- goto exit;
+ debug_msg(RELEASE, "Header Detected at %d\n", i + j);
+ goto exit;
}
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_MIDI_HEADER_LENGTH) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
ret = 0;
goto exit;
}
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(RELEASE, "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)) {
ret = 1;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected at %d\n", i + j);
-#endif
+ debug_msg(RELEASE, "Header Detected at %d\n", i + j);
goto exit;
}
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
mmfile_seek(fp, 0, MMFILE_SEEK_SET);
if (filesize < _MMFILE_MP4_HEADER_LENGTH) {
- debug_error("header is too small.\n");
+ debug_error(DEBUG, "header is too small.\n");
ret = 0;
goto exit;
}
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(RELEASE, "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
+ debug_msg(RELEASE, "MP4 Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected \n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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");
-#endif
+ debug_msg(RELEASE, "This is not a EBML format\n");
ret = 0;
goto exit;
}
/* length of header */
total = buffer[4];
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Initial total header size = [0x%x]\n", total);
-#endif
+
+ debug_msg(RELEASE, "Initial total header size = [0x%x]\n", total);
while (size <= 8 && !(total & len_mask)) {
- debug_error("This case can not be handled yet....");
+ debug_msg(DEBUG, "This case can not be handled yet....");
size++;
len_mask >>= 1;
}
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Final total header size = [%d]\n", total);
-#endif
+ debug_msg(RELEASE, "Final total header size = [%d]\n", total);
if (size > 8) {
- debug_error("This case can not be handled yet....");
+ debug_msg(DEBUG, "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_msg(DEBUG, "This case can not be handled yet....");
}
/* Does the probe data contain the whole header? */
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");
-#endif
+ debug_msg(RELEASE, "String matroska found!!!\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (1 == _MMFileIsFLACHeader(buffer)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected\n");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (1 == _MMFileIsFLVHeader(buffer)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected\n");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (1 == _MMFileIsREALHeader(buffer)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected\n");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
+
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "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");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (1 == _MMFileIsMPEGPSHeader(buffer)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected\n");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (1 == _MMFileIsMPEGAUDIOHeader(buffer)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected\n");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
if (fp == NULL) {
ret = mmfile_open(&fp, mmfileuri, MMFILE_RDONLY);
if (ret == MMFILE_IO_FAILED) {
- debug_error("error: mmfile_open\n");
+ debug_error(DEBUG, "error: mmfile_open\n");
goto exit;
}
}
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(RELEASE, "read error. size = %d. Maybe end of file.\n", readed);
ret = 0;
goto exit;
}
if (1 == _MMFileIsMPEGVIDEOHeader(buffer)) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Header Detected\n");
-#endif
+ debug_msg(RELEASE, "Header Detected\n");
ret = 1;
goto exit;
}
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(RELEASE, "read error occured.\n");
return 0;
}
if (memcmp(tagHeader, "ID3", 3) == 0) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("'ID3' found.\n");
-#endif
+ debug_msg(RELEASE, "'ID3' found.\n");
} else {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("'ID3' not found.\n");
-#endif
+ debug_msg(RELEASE, "'ID3' not found.\n");
goto search_end;
}
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
+ debug_msg(RELEASE, "good ID3V2 tag.\n");
} else {
- debug_warning("It's bad ID3V2 tag.\n");
+ debug_warning(DEBUG, "It's bad ID3V2 tag.\n");
goto search_end;
}
tagVersion = tagHeader[3];
if (tagVersion > 4) {
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("Tag version not supported\n");
-#endif
+ debug_msg(RELEASE, "Tag version not supported\n");
goto search_end;
}
/**@note unfortunately, some contents has many id3 tag.*/
acc_tagsize += tagInfoSize;
-#ifdef __MMFILE_TEST_MODE__
- debug_msg("tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
-#endif
+ debug_msg(RELEASE, "tag size: %u, offset: %u\n", tagInfoSize, acc_tagsize);
mmfile_seek(fp, acc_tagsize, MMFILE_SEEK_SET);
*offset = acc_tagsize;
projects / platform / core / multimedia / libmm-fileinfo.git / commitdiff