return MMFILE_CODEC_FAIL;
}
- codecObject = mmfile_malloc(sizeof(MMFileCodecContext));
- if (NULL == codecObject) {
- debug_error(DEBUG, "error: mmfile_malloc fail for codecObject\n");
- return MMFILE_CODEC_FAIL;
- }
+ codecObject = g_new0(MMFileCodecContext, 1);
*codecContext = codecObject;
} tMMFILE_AAC_TAG_INFO;
-int mmfile_aacparser_open(MMFileAACHandle *handle, const char *src);
+int mmfile_aacparser_open(MMFileAACHandle *handle, const char *path);
int mmfile_aacparser_get_stream_info(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo);
int mmfile_aacparser_get_tag_info(MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *info);
int mmfile_aacparser_get_next_frame(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo);
} tMMFILE_AMR_STREAM_INFO;
-int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *src);
+int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path);
int mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo);
int mmfile_amrparser_close(MMFileAMRHandle handle);
int readed = 0;
mmfile_seek(pData->hFile, pData->tagOffset, MMFILE_SEEK_SET);
- tagBuff = (unsigned char *) mmfile_malloc(hTag->fileLen);
- if (tagBuff == NULL) {
- ret = MMFILE_AAC_PARSER_FAIL;
- debug_error(DEBUG, "failed to memory allocation. %lld\n", hTag->fileLen);
- goto failure;
- }
+ mm_file_retvm_if_fails(DEBUG, hTag->fileLen > 0, MMFILE_AAC_PARSER_FAIL);
+ tagBuff = g_malloc0(hTag->fileLen);
readed = mmfile_read(pData->hFile, tagBuff, hTag->fileLen);
if (readed != hTag->fileLen) {
return ret;
}
-
-int mmfile_aacparser_open(MMFileAACHandle *handle, const char *filenamec)
+int mmfile_aacparser_open(MMFileAACHandle *handle, const char *path)
{
tMMFILE_AAC_HANDLE *privateData = NULL;
int ret = 0;
int firstFrameLen = 0;
int readed = 0;
- if (NULL == filenamec) {
- debug_error(DEBUG, "file source is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, path, MMFILE_AAC_PARSER_FAIL);
- privateData = mmfile_malloc(sizeof(tMMFILE_AAC_HANDLE));
- if (NULL == privateData) {
- debug_error(DEBUG, "file source is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
+ privateData = g_new0(tMMFILE_AAC_HANDLE, 1);
- ret = mmfile_open(&privateData->hFile, filenamec, MMFILE_RDONLY);
+ ret = mmfile_open(&privateData->hFile, path, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
debug_error(DEBUG, "error: mmfile_open\n");
goto exception;
EXPORT_API
int mmfile_format_read_stream_aac(MMFileFormatContext *formatContext)
{
- MMFileAACHandle handle = NULL;
- tMMFILE_AAC_STREAM_INFO aacinfo = {0, };
- MMFileFormatStream *audioStream = NULL;
-
+ MMFileAACHandle handle = NULL;
+ tMMFILE_AAC_STREAM_INFO aacinfo = {0, };
+ MMFileFormatStream *audioStream = NULL;
int ret = MMFILE_FORMAT_FAIL;
- if (NULL == formatContext) {
- debug_error(DEBUG, "error: invalid params\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
ret = mmfile_aacparser_get_stream_info(handle, &aacinfo);
- if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error(DEBUG, "error: mmfile_aacparser_get_stream_info\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, ret == MMFILE_FORMAT_SUCCESS, ret);
formatContext->isseekable = aacinfo.iseekable;
formatContext->duration = aacinfo.duration;
formatContext->audioTotalTrackNum = aacinfo.numTracks;
formatContext->nbStreams = 1;
- audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error(DEBUG, "error: calloc_audiostream\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ audioStream = g_new0(MMFileFormatStream, 1);
audioStream->streamType = MMFILE_AUDIO_STREAM;
audioStream->codecId = MM_AUDIO_CODEC_AAC;
mmfile_format_print_contents(formatContext);
#endif
- return MMFILE_FORMAT_SUCCESS;
-
-exception:
return ret;
}
EXPORT_API
int mmfile_format_read_tag_aac(MMFileFormatContext *formatContext)
{
- MMFileAACHandle handle = NULL;
- tMMFILE_AAC_TAG_INFO aacinfo = {0, };
+ MMFileAACHandle handle = NULL;
+ tMMFILE_AAC_TAG_INFO aacinfo = {0, };
int ret = MMFILE_FORMAT_FAIL;
- if (NULL == formatContext) {
- debug_error(DEBUG, "error: invalid params\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
ret = mmfile_aacparser_get_tag_info(handle, &aacinfo);
- if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_warning(DEBUG, "error: mmfile_aacparser_get_tag_info\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, ret == MMFILE_FORMAT_SUCCESS, ret);
formatContext->title = g_strdup(aacinfo.title);
formatContext->author = g_strdup(aacinfo.author);
formatContext->artworkMime = g_strdup(aacinfo.artworkMime);
if (aacinfo.artwork) {
formatContext->artworkSize = aacinfo.artworkSize;
- formatContext->artwork = mmfile_malloc(aacinfo.artworkSize);
- if (!formatContext->artwork) {
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
- memcpy(formatContext->artwork, aacinfo.artwork, aacinfo.artworkSize);
+ formatContext->artwork = g_memdup(aacinfo.artwork, aacinfo.artworkSize);
}
#ifdef __MMFILE_TEST_MODE__
mmfile_format_print_contents(formatContext);
#endif
- return MMFILE_FORMAT_SUCCESS;
-
-exception:
return ret;
}
long long sum_bitrate = 0;
long long frames_bitrate = 0;
- buf = mmfile_malloc(AMR_MAX_READ_BUF_SZ);
- if (!buf) {
- debug_error(DEBUG, "failed to memory allocaion.\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
+ buf = g_malloc0(AMR_MAX_READ_BUF_SZ);
for (readed = 0;;) {
readed = mmfile_read(pData->hFile, buf, AMR_MAX_READ_BUF_SZ);
pData->duration = pData->numFrames * MMFILE_AMR_FRAME_DUR;
pData->frameRate = 1000 / MMFILE_AMR_FRAME_DUR;
- if (frames_bitrate) {
+ if (frames_bitrate)
pData->bitRate = sum_bitrate / frames_bitrate;
- }
return ret;
}
-int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *filenamec)
+int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path)
{
tMMFILE_AMR_HANDLE *privateData = NULL;
int ret = 0;
- if (NULL == filenamec || NULL == handle) {
- debug_error(DEBUG, "file source is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, handle, MMFILE_AMR_PARSER_FAIL);
+ mm_file_retvm_if_fails(DEBUG, path, MMFILE_AMR_PARSER_FAIL);
- privateData = mmfile_malloc(sizeof(tMMFILE_AMR_HANDLE));
- if (NULL == privateData) {
- debug_error(DEBUG, "file source is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
+ privateData = g_new0(tMMFILE_AMR_HANDLE, 1);
/* Initialize the members of handle */
_amr_init_handle(privateData);
- ret = mmfile_open(&privateData->hFile, filenamec, MMFILE_RDONLY);
+ ret = mmfile_open(&privateData->hFile, path, MMFILE_RDONLY);
if (ret == MMFILE_UTIL_FAIL) {
debug_error(DEBUG, "error: mmfile_open\n");
goto exception;
tMMFILE_AMR_HANDLE *privateData = NULL;
int ret;
- if (NULL == handle || NULL == amrinfo) {
- debug_error(DEBUG, "handle is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, handle, MMFILE_AMR_PARSER_FAIL);
+ mm_file_retvm_if_fails(DEBUG, amrinfo, MMFILE_AMR_PARSER_FAIL);
privateData = (tMMFILE_AMR_HANDLE *) handle;
mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
ret = _parse_amr_stream(privateData);
- if (ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error(DEBUG, "Error in parsing the stream\n");
- return ret;
- }
+ mm_file_retvm_if_fails(DEBUG, ret == MMFILE_AMR_PARSER_SUCCESS, ret);
amrinfo->duration = privateData->duration;
amrinfo->fileSize = privateData->fileSize;
amrinfo->numAudioChannels = 1;
amrinfo->numTracks = 1;
- if (privateData->amrFormat == AMR_FORMAT_NB) {
+ if (privateData->amrFormat == AMR_FORMAT_NB)
amrinfo->samplingRate = AMR_NB_SAMPLES_PER_SEC;
- } else {
+ else
amrinfo->samplingRate = AMR_WB_SAMPLES_PER_SEC;
- }
return MMFILE_AMR_PARSER_SUCCESS;
}
{
tMMFILE_AMR_HANDLE *privateData = NULL;
- if (NULL == handle) {
- debug_error(DEBUG, "handle is NULL\n");
- return MMFILE_AMR_PARSER_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, handle, MMFILE_AMR_PARSER_FAIL);
privateData = (tMMFILE_AMR_HANDLE *) handle;
EXPORT_API
int mmfile_format_read_stream_amr(MMFileFormatContext *formatContext)
{
- MMFileAMRHandle handle = NULL;
- tMMFILE_AMR_STREAM_INFO amrinfo = {0, };
- MMFileFormatStream *audioStream = NULL;
-
+ MMFileAMRHandle handle = NULL;
+ tMMFILE_AMR_STREAM_INFO amrinfo = {0, };
+ MMFileFormatStream *audioStream = NULL;
int ret = MMFILE_FORMAT_FAIL;
- if (NULL == formatContext) {
- debug_error(DEBUG, "error: invalid params\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
ret = mmfile_amrparser_get_stream_info(handle, &amrinfo);
- if (MMFILE_FORMAT_SUCCESS != ret) {
- debug_error(DEBUG, "error: mmfile_amrparser_get_stream_info\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, ret == MMFILE_FORMAT_SUCCESS, ret);
formatContext->duration = amrinfo.duration;
formatContext->videoStreamId = -1;
formatContext->audioTotalTrackNum = amrinfo.numTracks;
formatContext->nbStreams = 1;
- audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error(DEBUG, "error: calloc_audiostream\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ audioStream = g_new0(MMFileFormatStream, 1);
audioStream->streamType = MMFILE_AUDIO_STREAM;
audioStream->codecId = MM_AUDIO_CODEC_AMR;
mmfile_format_print_contents(formatContext);
#endif
- return MMFILE_FORMAT_SUCCESS;
-
-exception:
return ret;
}
goto exception;
}
- memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
- if (!memHandle) {
- debug_error(DEBUG, "error: mmfile_malloc memHandle\n");
- goto exception;
- }
+ memHandle = g_new0(MMFmemIOHandle, 1);
memHandle->ptr = (unsigned char *)atoll(splitedString[0]); /*memory allocation address changed. memHandle->ptr = (unsigned char*)atoi(splitedString[0]); */
memHandle->size = atoi(splitedString[1]);
EXPORT_API
int mmfile_format_read_stream_ffmpg(MMFileFormatContext *formatContext)
{
- AVFormatContext *pFormatCtx = NULL;
- AVCodecParameters *pAudioCodecCtx = NULL;
- AVCodecParameters *pVideoCodecCtx = NULL;
-
- MMFileFormatStream *videoStream = NULL;
- MMFileFormatStream *audioStream = NULL;
+ AVFormatContext *pFormatCtx = NULL;
+ AVCodecParameters *pAudioCodecCtx = NULL;
+ AVCodecParameters *pVideoCodecCtx = NULL;
+ MMFileFormatStream *videoStream = NULL;
+ MMFileFormatStream *audioStream = NULL;
unsigned int i = 0;
int ret = 0;
- if (NULL == formatContext || NULL == formatContext->privateFormatData) {
- debug_error(DEBUG, "invalid param\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
+ mm_file_retvm_if_fails(DEBUG, formatContext->privateFormatData, MMFILE_FORMAT_FAIL);
pFormatCtx = formatContext->privateFormatData;
pFormatCtx->start_time = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++) {
if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
if (formatContext->videoStreamId == -1) {
- videoStream = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == videoStream) {
- debug_error(DEBUG, "mmfile_malloc error\n");
- goto exception;
- }
+ videoStream = g_new0(MMFileFormatStream, 1);
videoStream->streamType = MMFILE_VIDEO_STREAM;
formatContext->streams[MMFILE_VIDEO_STREAM] = videoStream;
}
} else if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if (formatContext->audioStreamId == -1) {
- audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error(DEBUG, "mmfile_malloc error\n");
- goto exception;
- }
+ audioStream = g_new0(MMFileFormatStream, 1);
audioStream->streamType = MMFILE_AUDIO_STREAM;
formatContext->streams[MMFILE_AUDIO_STREAM] = audioStream;
current_pos = mime_len + description_len + (DATA_LENGTH * 8); /*current position is picture data */
mmfile_free(formatContext->artwork);
- formatContext->artwork = mmfile_malloc(data_len);
- if (formatContext->artwork)
- memcpy(formatContext->artwork, meta_data + current_pos, data_len);
+ formatContext->artwork = g_memdup(meta_data + current_pos, data_len);
g_free(meta_data);
}
mmfile_free(formatContext->artwork);
formatContext->artworkSize = pkt.size;
- formatContext->artwork = mmfile_malloc(pkt.size);
- if (formatContext->artwork)
- memcpy(formatContext->artwork, pkt.data, pkt.size);
+ formatContext->artwork = g_memdup(pkt.data, pkt.size);
}
static void __fill_metainfo_in_context(AVDictionary *metainfo, MMFileFormatContext *formatContext)
}
numBytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, width, height, 1);
- if (numBytes < 0) {
+ if (numBytes <= 0) {
debug_error(DEBUG, "error: av_image_get_buffer_size. [%d x %d]\n", width, height);
ret = MMFILE_FORMAT_FAIL;
goto exception;
}
- frame->frameData = mmfile_malloc(numBytes);
- if (NULL == frame->frameData) {
- debug_error(DEBUG, "error: mmfile_malloc. [%d]\n", numBytes);
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ frame->frameData = g_malloc0(numBytes);
uint8_t *dst_data[4];
int dst_linesize[4];
goto exception;
}
- memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
- if (!memHandle) {
- debug_error(DEBUG, "error: mmfile_malloc memHandle\n");
- goto exception;
- }
+ memHandle = g_new0(MMFmemIOHandle, 1);
memHandle->ptr = (unsigned char *)atoll(splitedString[0]); /*memory allocation address changed. memHandle->ptr = (unsigned char*)atoi(splitedString[0]); */
memHandle->size = atoi(splitedString[1]);
goto exception;
}
- *frame = mmfile_malloc(*size);
- if (!(*frame)) {
- debug_error(DEBUG, "error: avpicture_get_size. [%d]\n", *size);
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ *frame = g_malloc0(*size);
debug_msg(RELEASE, "size : %d", *size);
debug_msg(RELEASE, "width : %d", *width);
formatContext->audioTotalTrackNum = info->track_num;
formatContext->nbStreams = 1;
-
- audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error(DEBUG, "error: mmfile_malloc audiostream\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ audioStream = g_new0(MMFileFormatStream, 1);
audioStream->streamType = MMFILE_AUDIO_STREAM;
audioStream->codecId = MM_AUDIO_CODEC_IMELODY;
}
/*alloc read buffer*/
- if ((buf = mmfile_malloc(src_size)) == NULL) {
- debug_error(DEBUG, "memory allocation failed.\n");
- goto failed;
- }
+ buf = g_malloc0(src_size);
/*read data*/
if ((readed = mmfile_read(fp, buf, src_size)) != src_size) {
static unsigned char *
__AvConvertIMelody2MIDI(char *pMelodyBuf, unsigned int *pBufLen)
{
- unsigned char *pConvertBuf;
char *pStart;
char *pMelodyStart;
int octaveCount;
*pBufLen = 6 * (count * (repeat + 1) + (noteCount - count)) + 56 - 1;
- pConvertBuf = (unsigned char *) mmfile_malloc(*pBufLen);
- if (pConvertBuf == NULL) {
- debug_error(DEBUG, "__AvConvertIMelody2MIDI: malloc failed!\n");
- return NULL;
- }
-
- memcpy(pConvertBuf, midiData, *pBufLen);
-
- return pConvertBuf;
+ return g_memdup(midiData, *pBufLen);
}
static unsigned char
formatContext->audioTotalTrackNum = info->track_num;
formatContext->nbStreams = 1;
- audioStream = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == audioStream) {
- debug_error(DEBUG, "error: mmfile_malloc audiostream\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
+ audioStream = g_new0(MMFileFormatStream, 1);
audioStream->streamType = MMFILE_AUDIO_STREAM;
audioStream->codecId = (info->is_xmf == 1) ? MM_AUDIO_CODEC_MXMF : MM_AUDIO_CODEC_MIDI;
return MMFILE_FORMAT_SUCCESS;
}
-static char *_lc_strdup(const char *str, unsigned int size)
-{
- char *t = NULL;
- t = mmfile_malloc(size + 1);
- if (t) {
- memset(t, 0x00, size + 1);
- memcpy(t, str, size);
- }
- return t;
-}
-
MIDI_INFO_SIMPLE *
mmfile_format_get_midi_infomation(char *szFileName)
{
- /*int duration = -1;*/
- MIDI_INFO_SIMPLE *info = NULL;
-
- info = mmfile_malloc(sizeof(MIDI_INFO_SIMPLE));
- if (!info)
- return NULL;
+ MIDI_INFO_SIMPLE *info = g_new0(MIDI_INFO_SIMPLE, 1);
- /*get infomation*/
- /*duration = */__AvGetMidiDuration(szFileName, info);
+ __AvGetMidiDuration(szFileName, info);
return info;
}
}
/*alloc read buffer*/
- pbFile = (UINT8 *) mmfile_malloc(sizeof(UINT8) * (dFileSize + 1));
- if (!pbFile) {
- debug_error(DEBUG, "memory allocation failed.\n");
- goto _RELEASE_RESOURCE;
- }
+ pbFile = g_malloc0(dFileSize + 1);
/*read data*/
if ((readed = mmfile_read(hFile, pbFile, dFileSize)) != dFileSize) {
info->track_num = gPi->dNumOfTracks;
info->is_xmf = is_xmf;
- info->title = _lc_strdup((const char *)gPi->pbTitle, gPi->dSizeTitle);
- info->copyright = _lc_strdup((const char *)gPi->pbCopyright, gPi->dSizeCopyright);
- info->comment = _lc_strdup((const char *)gPi->pbText, gPi->dSizeText);
+ info->title = g_strndup((const char *)gPi->pbTitle, gPi->dSizeTitle);
+ info->copyright = g_strndup((const char *)gPi->pbCopyright, gPi->dSizeCopyright);
+ info->comment = g_strndup((const char *)gPi->pbText, gPi->dSizeText);
}
_RELEASE_RESOURCE:
static SINT32
__AvMidFile_Initialize(void)
{
- gpMidInfo = mmfile_malloc(sizeof(MIDGLOBAL));
-
- if (!gpMidInfo)
- return (AvSMW_ERROR);
-
- memset(gpMidInfo, 0x00, sizeof(MIDGLOBAL));
+ gpMidInfo = g_new0(MIDGLOBAL, 1);
gpMidInfo->sdSeqID = -1; /* Sequence ID */
gpMidInfo->sdFileID = -1; /* File ID */
int total = 0;
total = mmf_file_mmf_get_duration(formatContext->uriFileName, 0 /*not XMF*/);
- if (total < 0) {
- debug_error(DEBUG, "error: get duration\n");
- return MMFILE_FORMAT_FAIL;
- }
-
+ mm_file_retvm_if_fails(DEBUG, total >= 0, MMFILE_FORMAT_FAIL);
formatContext->duration = total;
formatContext->audioTotalTrackNum = 1;
formatContext->nbStreams = 1;
- formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc(sizeof(MMFileFormatStream));
- if (NULL == formatContext->streams[MMFILE_AUDIO_STREAM]) {
- debug_error(DEBUG, "error: mmfile_malloc, audido stream\n");
- return MMFILE_FORMAT_FAIL;
- }
-
+ formatContext->streams[MMFILE_AUDIO_STREAM] = g_new0(MMFileFormatStream, 1);
formatContext->streams[MMFILE_AUDIO_STREAM]->codecId = MM_AUDIO_CODEC_MMF;
formatContext->streams[MMFILE_AUDIO_STREAM]->nbChannel = 1;
}
/*alloc work buffer*/
- buf = mmfile_malloc(src_size + 1);
- if (!buf) {
- debug_error(DEBUG, "failed to memory allocaion.\n");
- ret_msec = -1;
- goto _RELEASE_RESOURCE;
- }
-
+ buf = g_malloc0(src_size + 1);
/*read data*/
if ((readed = mmfile_read(fp, buf, src_size)) <= 0) {
debug_fenter(RELEASE);
- if (NULL == formatContext) {
- debug_error(DEBUG, "formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
ret = MMFileFormatIsValidMP3(NULL, formatContext->uriFileName, 5);
if (ret == 0) {
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 1;
- privateData = mmfile_malloc(sizeof(AvFileContentInfo));
- if (!privateData) {
- debug_error(DEBUG, "error: mmfile_malloc MP3 privateData\n");
- return MMFILE_FORMAT_FAIL;
- }
+ privateData = g_new0(AvFileContentInfo, 1);
formatContext->privateFormatData = privateData;
debug_fenter(RELEASE);
- if (!formatContext || !formatContext->privateFormatData) {
- debug_error(DEBUG, "formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
+ mm_file_retvm_if_fails(DEBUG, formatContext->privateFormatData, MMFILE_FORMAT_FAIL);
if (MMFILE_FORMAT_SUCCESS != mmf_file_mp3_get_stream_info(formatContext->uriFileName, formatContext->privateFormatData)) {
debug_error(DEBUG, "getting stream information is failed");
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 1;
formatContext->nbStreams = 1;
- formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc(sizeof(MMFileFormatStream));
- if (!formatContext->streams[MMFILE_AUDIO_STREAM]) {
- debug_error(DEBUG, "formatContext->streams[MMFILE_AUDIO_STREAM] is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
-
+ formatContext->streams[MMFILE_AUDIO_STREAM] = g_new0(MMFileFormatStream, 1);
formatContext->streams[MMFILE_AUDIO_STREAM]->streamType = MMFILE_AUDIO_STREAM;
formatContext->streams[MMFILE_AUDIO_STREAM]->codecId = MM_AUDIO_CODEC_MP3;
formatContext->streams[MMFILE_AUDIO_STREAM]->bitRate = (privateData->bitRate * 1000);
debug_fenter(RELEASE);
- if (!formatContext || !formatContext->privateFormatData) {
- debug_error(DEBUG, "formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
+ mm_file_retvm_if_fails(DEBUG, formatContext->privateFormatData, MMFILE_FORMAT_FAIL);
if (MMFILE_FORMAT_SUCCESS != mmf_file_mp3_get_tag_info(formatContext->uriFileName, formatContext->privateFormatData)) {
debug_error(DEBUG, "getting tag information is failed");
formatContext->part_of_set = g_strdup(privateData->tagInfo[AV_ID3TAG_PART_OF_SET].value);
if (privateData->imageInfo.imageLen > 0) {
- formatContext->artwork = mmfile_malloc(privateData->imageInfo.imageLen);
- if (formatContext->artwork) {
- formatContext->artworkSize = privateData->imageInfo.imageLen;
- memcpy(formatContext->artwork, privateData->imageInfo.pImageBuf, privateData->imageInfo.imageLen);
- if (strlen(privateData->imageInfo.imageMIMEType) > 0)
- formatContext->artworkMime = g_strdup(privateData->imageInfo.imageMIMEType);
- else if (strlen(privateData->imageInfo.imageExt) > 0) {
- debug_msg(RELEASE, "ID3 tag V2 File");
- formatContext->artworkMime = g_strdup(privateData->imageInfo.imageExt);
- } else {
- debug_error(DEBUG, "Album art image exist but there is no type information of album art\n");
- }
+ formatContext->artworkSize = privateData->imageInfo.imageLen;
+ formatContext->artwork = g_memdup(privateData->imageInfo.pImageBuf, privateData->imageInfo.imageLen);
+
+ if (strlen(privateData->imageInfo.imageMIMEType) > 0)
+ formatContext->artworkMime = g_strdup(privateData->imageInfo.imageMIMEType);
+ else if (strlen(privateData->imageInfo.imageExt) > 0) {
+ debug_msg(RELEASE, "ID3 tag V2 File");
+ formatContext->artworkMime = g_strdup(privateData->imageInfo.imageExt);
+ } else {
+ debug_error(DEBUG, "Album art image exist but there is no type information of album art\n");
}
}
if (buf[0] == 0xff) {
if (VALID_SYNC(buf)) {
if (bufLen - index > 256) {
- pHeader = mmfile_malloc(256);
- if (pHeader == NULL) {
- debug_error(DEBUG, "malloc failed.\n");
- return -1;
- }
+ pHeader = g_malloc0(256);
strncpy((char *)pHeader, (char *)buf, 256);
} else {
debug_error(DEBUG, "Header field is not exist\n");
}
/* read file to check ID3v2 header */
- v2TagExistCheck = mmfile_malloc(MP3_TAGv2_HEADER_LEN);
- if (!v2TagExistCheck) {
- debug_error(DEBUG, "malloc failed.\n");
- goto EXCEPTION;
- }
+ v2TagExistCheck = g_malloc0(MP3_TAGv2_HEADER_LEN);
if (mmfile_read(hFile, v2TagExistCheck, MP3_TAGv2_HEADER_LEN) != MP3_TAGv2_HEADER_LEN) {
debug_error(DEBUG, "v2TagExistCheck value read fail!\n");
debug_msg(RELEASE, "buf size(%d)\n", pInfo->tagV2Info.tagLen);
- buf = mmfile_malloc(pInfo->tagV2Info.tagLen);
- if (!buf) {
- debug_error(DEBUG, "malloc failed.\n");
- goto EXCEPTION;
- }
+ buf = g_malloc0(pInfo->tagV2Info.tagLen);
if (mmfile_read(hFile, buf, pInfo->tagV2Info.tagLen) != pInfo->tagV2Info.tagLen) {
mmfile_free(buf);
debug_msg(RELEASE, "buf size(%lu)\n", bufLen);
- buf = mmfile_malloc(bufLen);
- if (!buf)
- goto EXCEPTION;
+ buf = g_malloc0(bufLen);
if (mmfile_read(hFile, buf, bufLen) != (int)bufLen) {
mmfile_free(buf);
tMMFileTagsData *privateData = NULL;
int ret = 0;
- privateData = mmfile_malloc(sizeof(tMMFileTagsData));
- if (!privateData) {
- debug_error(DEBUG, "mmfile_malloc: tMMFileTagsData\n");
- return MMFILE_TAGS_FAIL;
- }
+ privateData = g_new0(tMMFileTagsData, 1);
*tagsHandle = privateData;
tMMFileTags *tagData = NULL;
int ret = 0;
- if (!privateData || !privateData->fp) {
- debug_error(DEBUG, "Invalid argument\n");
- return MMFILE_TAGS_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, privateData, MMFILE_TAGS_FAIL);
+ mm_file_retvm_if_fails(DEBUG, privateData->fp, MMFILE_TAGS_FAIL);
- tagData = mmfile_malloc(sizeof(tMMFileTags));
- if (!tagData) {
- debug_error(DEBUG, "mmfile_malloc tagData\n");
- return MMFILE_TAGS_FAIL;
- }
+ tagData = g_new0(tMMFileTags, 1);
ret = FindTag(privateData->fp, bAppended, privateData->startOffset, privateData->endOffset, tagData);
if (ret) {
privateData->startOffset = tagData->endOffset;
}
- /* add tagData into privateData->tagList */
-
- /*privateData->tagList = mmfile_list_append(privateData->tagList, tagData); */
-
ret = MMFILE_TAGS_SUCCESS;
}
MMFileIOHandle *fp = NULL;
int ret = 0;
- if (formatContext == NULL) {
- debug_error(DEBUG, "formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
header = mmf_file_wave_get_header(formatContext->uriFileName);
- if (header == NULL) {
- debug_error(DEBUG, "error: mmf_file_wave_get_header\n");
- goto exception;
- }
+ mm_file_retvm_if_fails(DEBUG, header, MMFILE_FORMAT_FAIL);
- waveinfo = mmfile_malloc(sizeof(MM_FILE_WAVE_INFO));
- if (waveinfo == NULL) {
- debug_error(DEBUG, "error: mmfile_malloc\n");
- goto exception;
- }
+ waveinfo = g_new0(MM_FILE_WAVE_INFO, 1);
ret = mmf_file_wave_get_info(header, waveinfo);
+ mmfile_free(header);
if (ret == -1) {
debug_error(DEBUG, "error: mmf_file_wave_get_info\n");
- goto exception;
+ mmfile_free(waveinfo);
+ return MMFILE_FORMAT_FAIL;
}
- mmfile_free(header);
-
/* Get file size. because sometimes waveinfo->size is wrong */
ret = mmfile_open(&fp, formatContext->uriFileName, MMFILE_RDONLY);
if (fp) {
formatContext->audioTotalTrackNum = 1;
formatContext->nbStreams = 1;
- formatContext->streams[MMFILE_AUDIO_STREAM] = mmfile_malloc(sizeof(MMFileFormatStream));
-
- if (!formatContext->streams[MMFILE_AUDIO_STREAM]) {
- debug_error(DEBUG, "error: mmfile_malloc audio stream for wav\n");
- return MMFILE_FORMAT_FAIL;
- }
-
+ formatContext->streams[MMFILE_AUDIO_STREAM] = g_new0(MMFileFormatStream, 1);
formatContext->streams[MMFILE_AUDIO_STREAM]->streamType = MMFILE_AUDIO_STREAM;
switch (waveinfo->format) {
formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa = __check_uhqa(waveinfo->sample_rate, waveinfo->bits_per_sample);
return MMFILE_FORMAT_SUCCESS;
-
-exception:
- mmfile_free(header);
- mmfile_free(waveinfo);
-
- return MMFILE_FORMAT_FAIL;
}
long long offset = 0;
long long limit;
- header = mmfile_malloc(MMF_FILE_WAVE_HEADER_LEN);
- if (!header)
- return NULL;
+ header = g_malloc0(MMF_FILE_WAVE_HEADER_LEN);
/*open*/
ret = mmfile_open(&fp, src, MMFILE_RDONLY);
#else
const char *uriStr = MMFILE_FILE_URI;
#endif
- int uriLen = strlen(uriStr);
-
fileName = (const char *)(fileSrc->file.path);
filename_len = strlen(fileName);
int pos = filename_len;
- *urifilename = mmfile_malloc(uriLen + filename_len + 1);
- if (!*urifilename) {
- debug_error(DEBUG, "error: mmfile_malloc uriname\n");
- goto FILE_FORMAT_FAIL;
- }
-
- memset(*urifilename, 0x00, uriLen + filename_len + 1);
- SAFE_STRLCPY(*urifilename, uriStr, uriLen + filename_len + 1);
- SAFE_STRLCAT(*urifilename, fileName, uriLen + filename_len + 1);
+ *urifilename = g_strconcat(uriStr, fileName, NULL);
/**
* Get file extension from file's name
int ret = 0;
MMFileFormatContext *formatObject = NULL;
- if (NULL == fileSrc) {
- debug_error(DEBUG, "error: invalid params\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, fileSrc, MMFILE_FORMAT_FAIL);
/* create formatContext object */
- formatObject = mmfile_malloc(sizeof(MMFileFormatContext));
- if (NULL == formatObject) {
- debug_error(DEBUG, "error: mmfile_malloc fail for formatObject\n");
- *formatContext = NULL;
- return MMFILE_FORMAT_FAIL;
- }
-
- memset(formatObject, 0x00, sizeof(MMFileFormatContext));
+ formatObject = g_new0(MMFileFormatContext, 1);
mmfile_register_io_all();
/**
* Open format function.
*/
-#if 0
- if (NULL == MMFileFunc[formatObject->formatType].Open) {
- debug_error(DEBUG, "error: Not implemented \n");
- ret = MMFILE_FORMAT_FAIL;
- goto find_valid_handler;
- }
-#endif
ret = MMFileFunc[formatObject->formatType].Open(formatObject);
if (MMFILE_FORMAT_FAIL == ret) {
debug_error(DEBUG, "error: Try other formats\n");
ret = MMFILE_FORMAT_FAIL;
-/* goto find_valid_handler; */
goto exception;
}
*formatContext = formatObject;
return MMFILE_FORMAT_SUCCESS;
-
-#if 0 //Below code is duplicated with _PreprocessFile()
-find_valid_handler:
- formatObject->pre_checked = 0; /*do check file format*/
-
- for (index = 0; index < MM_FILE_FORMAT_NUM + 1; index++) {
- if (NULL == MMFileFunc[index].Open) {
- debug_error(DEBUG, "error: Not implemented \n");
- ret = MMFILE_FORMAT_FAIL;
- continue;
- }
-
- if (formatObject->formatType == index)
- continue;
-
- ret = MMFileFunc[index].Open(formatObject);
- if (MMFILE_FORMAT_FAIL == ret) {
-/* _CleanupFrameContext(formatObject, true); */
- continue;
- }
-
- break;
- }
-
- formatObject->formatType = index;
-
- if (index == MM_FILE_FORMAT_NUM + 1 && MMFILE_FORMAT_FAIL == ret) {
- debug_error(DEBUG, "can't find file format handler\n");
- _CleanupFrameContext(formatObject, true);
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
-
- formatObject->formatType = index;
- *formatContext = formatObject;
-
- return MMFILE_FORMAT_SUCCESS;
-#endif
-
exception:
_mmfile_format_close(formatObject, true);
*formatContext = NULL;
mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_UNSYNCLYRICS, formatContext->unsyncLyrics);
if (formatContext->artwork && formatContext->artworkSize > 0) {
- void *artworkCopy = NULL;
- artworkCopy = mmfile_malloc((formatContext->artworkSize));
- if (artworkCopy) {
- memcpy(artworkCopy, formatContext->artwork, formatContext->artworkSize);
- mm_attrs_set_data_by_name(attrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
- mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
- mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
- }
+ void *artworkCopy = g_memdup(formatContext->artwork, formatContext->artworkSize);
+
+ mm_attrs_set_data_by_name(attrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
+ mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
+ mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
}
} else if (formatContext->commandType == MM_FILE_CONTENTS) {
/*get duration*/
if (formatContext->thumbNail && formatContext->thumbNail->frameData) {
void *thumbNailCopy = NULL;
- thumbNailCopy = mmfile_malloc(formatContext->thumbNail->frameSize);
+ thumbNailCopy = g_memdup(formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
- if (thumbNailCopy) {
- memcpy(thumbNailCopy, formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
- mm_attrs_set_data_by_name(attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
- mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
- mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
- }
+ mm_attrs_set_data_by_name(attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
+ mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
+ mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
}
}
}
/* set video thumbnail */
- thumbnail = mmfile_malloc(sizeof(MMFileFormatFrame));
- if (!thumbnail) {
- debug_error(DEBUG, "error: mmfile_malloc\n");
- ret = FILEINFO_ERROR_FILE_INTERNAL;
- goto exception;
- }
+ thumbnail = g_new0(MMFileFormatFrame, 1);
if (frameContext.bCompressed) {
ret = __decode_contents_frame(&frameContext, formatContext->streams[MMFILE_VIDEO_STREAM], &decodedFrame);
noinst_HEADERS = include/mm_file_utils.h
-libmmfile_utils_la_SOURCES = mm_file_util_memory.c \
- mm_file_util_io.c \
+libmmfile_utils_la_SOURCES = mm_file_util_io.c \
mm_file_util_io_file.c \
mm_file_util_io_mem.c \
mm_file_util_io_mmap.c \
/*////////////////////////////////////////////////////////////////////// */
/* MEMORY DEBUG API // */
/*////////////////////////////////////////////////////////////////////// */
-void *mmfile_malloc_debug(unsigned int size, const char *func, unsigned int line);
-void *mmfile_calloc_debug(unsigned int nmemb, unsigned int size, const char *func, unsigned int line);
-void mmfile_free_debug(void *ptr, const char *func, unsigned int line);
-void *mmfile_realloc_debug(void *ptr, unsigned int size, const char *func, unsigned int line);
-void *mmfile_memset_debug(void *s, int c, unsigned int n, const char *func, unsigned int line);
-void *mmfile_memcpy_debug(void *dest, const void *src, unsigned int n, const char *func, unsigned int line);
char *mmfile_string_convert_debug(const char *str, unsigned int len, const char *to_codeset, const char *from_codeset,
int *bytes_read,
int *bytes_written,
const char *func,
unsigned int line);
-#define mmfile_malloc(size) mmfile_malloc_debug((size), __func__, __LINE__)
-#define mmfile_calloc(nmemb, size) mmfile_calloc_debug((nmemb), (size), __func__, __LINE__)
-#define mmfile_free(ptr) do { mmfile_free_debug((ptr), __func__, __LINE__); (ptr) = NULL; } while (0)
-#define mmfile_realloc(ptr, size) mmfile_realloc_debug((ptr), (size), __func__, __LINE__)
-#define mmfile_memset(ptr, c, n) mmfile_memset_debug((ptr), (c), (n), __func__, __LINE__)
-#define mmfile_memcpy(dest, src, n) mmfile_memcpy_debug((ptr), (src), (n), __func__, __LINE__)
#define mmfile_string_convert(str, len, to_codeset, from_codeset, bytes_read, bytes_written) mmfile_string_convert_debug((str), (len), (to_codeset), (from_codeset), (bytes_read), (bytes_written), __func__, __LINE__)
-#else
-/*////////////////////////////////////////////////////////////////////// */
-/* MEMORY API // */
-/*////////////////////////////////////////////////////////////////////// */
-void *mmfile_malloc(unsigned int size);
-void *mmfile_calloc(unsigned int nmemb, unsigned int size);
-#define mmfile_free(ptr) do { if ((ptr)) { mmfile_free_r((ptr)); (ptr) = NULL; } } while (0)
-void mmfile_free_r(void *ptr);
-void *mmfile_realloc(void *ptr, unsigned int size);
-void *mmfile_memset(void *s, int c, unsigned int n);
-void *mmfile_memcpy(void *dest, const void *src, unsigned int n);
#endif
+#define mmfile_free(ptr) do { g_free((ptr)); (ptr) = NULL; } while (0)
+
/*////////////////////////////////////////////////////////////////////// */
goto fail;
}
- pHandle = mmfile_malloc(sizeof(MMFileIOHandle));
- if (!pHandle) {
- debug_error(DEBUG, "mmfile_malloc: pHandle\n");
- err = MMFILE_IO_FAILED;
- goto fail;
- }
+ pHandle = g_new0(MMFileIOHandle, 1);
*handle = pHandle;
return MMFILE_IO_FAILED;
}
- privateData = mmfile_malloc(sizeof(tMMFORMAT_FILEIO_DATA));
- if (!privateData) {
- close(fd);
- debug_error(DEBUG, "calloc privateData\n");
- return MMFILE_IO_FAILED;
- }
+ privateData = g_new0(tMMFORMAT_FILEIO_DATA, 1);
privateData->fd = fd;
privateData->offset = 0;
goto exception;
}
- memHandle = mmfile_malloc(sizeof(MMFmemIOHandle));
- if (!memHandle) {
- debug_error(DEBUG, "error: mmfile_malloc memHandle\n");
- goto exception;
- }
+ memHandle = g_new0(MMFmemIOHandle, 1);
memHandle->ptr = (unsigned char *)atoll(splitedString[0]); /*memory allocation address changed. memHandle->ptr = (unsigned char*)atoi(splitedString[0]); */
memHandle->size = atoi(splitedString[1]);
filename += strlen(handle->iofunc->handleName) + 3; /* :// */
- memset(&finfo, 0x00, sizeof(struct stat));
-
- mmapHandle = mmfile_malloc(sizeof(MMFMMapIOHandle));
- if (!mmapHandle) {
- debug_error(DEBUG, "error: mmfile_malloc mmapHandle\n");
- return MMFILE_IO_FAILED;
- }
+ mmapHandle = g_new0(MMFMMapIOHandle, 1);
#ifdef O_BINARY
access |= O_BINARY;
+++ /dev/null
-/*
- * libmm-fileinfo
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Haejeong Kim <backto.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include "mm_file_utils.h"
-
-#ifdef __MMFILE_MEM_TRACE__
-EXPORT_API
-void *mmfile_malloc_debug(unsigned int size, const char *func, unsigned int line)
-{
- void *tmp = malloc(size);
-
- if (tmp) {
- memset(tmp, 0x00, size);
- debug_msg(RELEASE, "## DEBUG ## %p = malloc (%d) by %s() %d\n", tmp, size, func, line);
- }
- return tmp;
-}
-
-EXPORT_API
-void *mmfile_calloc_debug(unsigned int nmemb, unsigned int size, const char *func, unsigned int line)
-{
- void *tmp = calloc(nmemb, size);
-
- if (tmp) {
- debug_msg(RELEASE, "## DEBUG ## %p = calloc (%d, %d) by %s() %d\n", tmp, nmemb, size, func, line);
- }
- return tmp;
-}
-
-EXPORT_API
-void mmfile_free_debug(void *ptr, const char *func, unsigned int line)
-{
- if (ptr) {
- debug_msg(RELEASE, "## DEBUG ## free (%p) by %s() %d\n", ptr, func, line);
- free(ptr);
- }
-}
-
-
-EXPORT_API
-void *mmfile_realloc_debug(void *ptr, unsigned int size, const char *func, unsigned int line)
-{
- void *tmp = realloc(ptr, size);
-
- if (tmp) {
- 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)
-{
- 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)
-{
- debug_msg(RELEASE, "## DEBUG ## memcpy (%p, %p, %d) by %s() %d\n", dest, src, n, func, line);
-
- return memcpy(dest, src, n);
-}
-
-#else /* __MMFILE_MEM_TRACE__ : ------------------------------------------------------------------*/
-
-EXPORT_API
-void *mmfile_malloc(unsigned int size)
-{
- void *tmp = malloc(size);
- if (tmp) {
- memset(tmp, 0x00, size);
- }
- return tmp;
-}
-
-EXPORT_API
-void *mmfile_calloc(unsigned int nmemb, unsigned int size)
-{
- void *tmp = calloc(nmemb, size);
- return tmp;
-}
-
-EXPORT_API
-void mmfile_free_r(void *ptr)
-{
- if (ptr) free(ptr);
-}
-
-EXPORT_API
-void *mmfile_realloc(void *ptr, unsigned int size)
-{
- return realloc(ptr, size);
-}
-
-EXPORT_API
-void *mmfile_memset(void *s, int c, unsigned int n)
-{
- return memset(s, c, n);
-}
-
-EXPORT_API
-void *mmfile_memcpy(void *dest, const void *src, unsigned int n)
-{
- return memcpy(dest, src, n);
-}
-#endif
-
goto exception;
}
- texttag.text = mmfile_malloc(textBytes);
- if (!texttag.text) {
- debug_error(DEBUG, "malloc fail for text box\n");
- ret = MMFILE_UTIL_FAIL;
- goto exception;
- }
+ texttag.text = g_malloc0(textBytes);
readed = mmfile_read(fp, (unsigned char *)texttag.text, textBytes);
if (readed != textBytes) {
if (albumTitleLen > 1) { /* there exist only 00(null) */
debug_msg(RELEASE, "albumTitleLen=%d\n", albumTitleLen);
- albumbox.albumtile = mmfile_malloc(albumTitleLen + 1); /* 1: for null char */
- if (!albumbox.albumtile) {
- debug_error(DEBUG, "malloc fail for album title text\n");
- goto exception;
- }
+ albumbox.albumtile = g_malloc0(albumTitleLen + 1); /* 1: for null char */
readed = mmfile_read(fp, (unsigned char *)albumbox.albumtile, albumTitleLen);
if (readed != albumTitleLen) {
goto exception;
}
- ratingTag.ratingInfo = mmfile_malloc(ratinginfoLen);
- if (!ratingTag.ratingInfo) {
- debug_error(DEBUG, "rating info error\n");
- goto exception;
- }
+ ratingTag.ratingInfo = g_malloc0(ratinginfoLen);
readed = mmfile_read(fp, (unsigned char *)ratingTag.ratingInfo, ratinginfoLen);
if (readed != ratinginfoLen) {
goto exception;
}
- classTag.classificationInfo = mmfile_malloc(classinfoLen);
- if (!classTag.classificationInfo) {
- debug_error(DEBUG, "class info error\n");
- goto exception;
- }
+ classTag.classificationInfo = g_malloc0(classinfoLen);
readed = mmfile_read(fp, (unsigned char *)classTag.classificationInfo, classinfoLen);
if (readed != classinfoLen) {
goto exception;
}
- buffer = mmfile_malloc(bufferLen);
- if (!buffer) {
- debug_error(DEBUG, "buffer malloc error\n");
- goto exception;
- }
+ buffer = g_malloc0(bufferLen);
readed = mmfile_read(fp, (unsigned char *)buffer, bufferLen);
if (readed != bufferLen) {
}
debug_msg(RELEASE, "----------------------------------- new artist will be allocated with size (len+1) [%d] \n", artist_sz + 1);
- formatContext->artist = mmfile_malloc(artist_sz + 1);
+ formatContext->artist = g_malloc0(artist_sz + 1);
if (formatContext->artist) {
readed = mmfile_read(fp, (unsigned char *)formatContext->artist, artist_sz);
if (cover_sz > 0) {
mmfile_seek(fp, cover_offset, SEEK_SET);
- formatContext->artwork = mmfile_malloc(cover_sz);
+ formatContext->artwork = g_malloc0(cover_sz);
formatContext->artworkSize = cover_sz;
if (cover_type == _ITUNES_COVER_TYPE_JPEG) {
formatContext->artworkMime = g_strdup("image/jpeg");
id3v2Len = id3v2BoxHeader.size - MMFILE_MP4_BASIC_BOX_HEADER_LEN - MMFILE_3GP_ID3V2_BOX_LEN;
- id3v2Box.id3v2Data = mmfile_malloc(id3v2Len);
- if (!id3v2Box.id3v2Data) {
- debug_error(DEBUG, "malloc id3tag data error\n");
- goto exception;
- }
+ id3v2Box.id3v2Data = g_malloc0(id3v2Len);
readed = mmfile_read(fp, (unsigned char *)id3v2Box.id3v2Data, id3v2Len);
if (readed != id3v2Len) {
formatContext->classification = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_CONTENT_GROUP].value);
formatContext->conductor = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_CONDUCTOR].value);
- formatContext->artwork = mmfile_malloc(tagInfo.imageInfo.imageLen);
- if ((tagInfo.imageInfo.imageLen > 0) && formatContext->artwork) {
+ if (tagInfo.imageInfo.pImageBuf && tagInfo.imageInfo.imageLen > 0) {
formatContext->artworkSize = tagInfo.imageInfo.imageLen;
- memcpy(formatContext->artwork, tagInfo.imageInfo.pImageBuf, tagInfo.imageInfo.imageLen);
+ formatContext->artwork = g_memdup(tagInfo.imageInfo.pImageBuf, tagInfo.imageInfo.imageLen);
}
mm_file_free_AvFileContentInfo(&tagInfo);
static void _mm_file_id3tag_add_bracket_at_genre(char **genre, int genre_len)
{
int int_genre = -1;
- char tmp_genre[6] = {0, };
- int tmp_genre_len = 0;
if (!genre || !(*genre) || genre_len <= 0)
return;
/* Change int to string with bracket like "(123)"
* mm_file_id3tag_restore_content_info convert it to string
*/
- memset(tmp_genre, 0, sizeof(tmp_genre));
- snprintf(tmp_genre, sizeof(tmp_genre), "(%d)", int_genre);
-
- tmp_genre_len = strlen(tmp_genre);
- if (tmp_genre_len > 0) {
- *genre = mmfile_realloc(*genre, sizeof(char) * (tmp_genre_len + 1));
- if (*genre)
- SAFE_STRLCPY(*genre, tmp_genre, tmp_genre_len + 1);
- }
+ mmfile_free(*genre);
+ *genre = g_strdup_printf("(%d)", int_genre);
}
static void __id3tag_skip_newline(unsigned char *pTagVal, int *nTagLen, int *offset)
for (idx = 0; idx < nTagLen; idx++) {
if (pTagVal[offset + idx] == 0x00) {
- synclyrics_info = (AvSynclyricsInfo *)mmfile_malloc(sizeof(AvSynclyricsInfo));
- if (synclyrics_info) {
- if (textEncodingType == AV_ID3V2_UTF8) {
- synclyrics_info->lyric_info = mmfile_malloc(copy_len + 1);
- if (synclyrics_info->lyric_info) {
- memset(synclyrics_info->lyric_info, 0, copy_len + 1);
- memcpy(synclyrics_info->lyric_info, pTagVal + copy_start_pos, copy_len);
- synclyrics_info->lyric_info[copy_len] = '\0';
- }
- } else {
- synclyrics_info->lyric_info = mmfile_string_convert((const char *)&pTagVal[copy_start_pos], copy_len, "UTF-8", pCharSet, NULL, NULL);
- }
-
- synclyrics_info->time_info = (unsigned long)pTagVal[offset + idx + 1] << 24 | (unsigned long)pTagVal[offset + idx + 2] << 16 | (unsigned long)pTagVal[offset + idx + 3] << 8 | (unsigned long)pTagVal[offset + idx + 4];
- idx += 4;
- copy_start_pos = offset + idx + 1;
- debug_msg(RELEASE, "[%lu][%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);
- }
+ synclyrics_info = g_new0(AvSynclyricsInfo, 1);
+ if (textEncodingType == AV_ID3V2_UTF8)
+ synclyrics_info->lyric_info = g_memdup(pTagVal + copy_start_pos, copy_len + 1);
+ else
+ synclyrics_info->lyric_info = mmfile_string_convert((const char *)&pTagVal[copy_start_pos], copy_len, "UTF-8", pCharSet, NULL, NULL);
+
+ synclyrics_info->time_info = (unsigned long)pTagVal[offset + idx + 1] << 24 | (unsigned long)pTagVal[offset + idx + 2] << 16 | (unsigned long)pTagVal[offset + idx + 3] << 8 | (unsigned long)pTagVal[offset + idx + 4];
+ idx += 4;
+ copy_start_pos = offset + idx + 1;
+ debug_msg(RELEASE, "[%lu][%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++;
}
tag_len = idx + 1; /* length of description + '\0' */
- tmp_desc = mmfile_calloc(1, sizeof(char) * tag_len);
- if (tmp_desc) {
- memcpy(tmp_desc, pTagVal + *offset, tag_len);
+ tmp_desc = g_memdup(pTagVal + *offset, tag_len);
- /* convert description */
- pInfo->imageInfo.imageDescription = mmfile_string_convert(tmp_desc, tag_len, "UTF-8", pCharSet, NULL, &desc_len);
- pInfo->imageInfo.imgDesLen = (int)desc_len;
- mmfile_free(tmp_desc);
- debug_msg(RELEASE, "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, pInfo->imageInfo.imgDesLen);
- }
+ /* convert description */
+ pInfo->imageInfo.imageDescription = mmfile_string_convert(tmp_desc, tag_len, "UTF-8", pCharSet, NULL, &desc_len);
+ pInfo->imageInfo.imgDesLen = (int)desc_len;
+ mmfile_free(tmp_desc);
+ debug_msg(RELEASE, "new_desc %s(%d)\n", pInfo->imageInfo.imageDescription, pInfo->imageInfo.imgDesLen);
*offset += idx;
if ((pTagVal[*offset] != '\0') || (nTagLen <= *offset)) {
}
pInfo->imageInfo.imageLen = nTagLen - *offset;
- pInfo->imageInfo.pImageBuf = mmfile_malloc(pInfo->imageInfo.imageLen + 1);
-
- if (pInfo->imageInfo.pImageBuf) {
- memcpy(pInfo->imageInfo.pImageBuf, pTagVal + *offset, pInfo->imageInfo.imageLen);
- pInfo->imageInfo.pImageBuf[pInfo->imageInfo.imageLen] = 0;
- }
+ pInfo->imageInfo.pImageBuf = g_memdup(pTagVal + *offset, pInfo->imageInfo.imageLen + 1);
/* if mimetype is "-->", image date has an URL */
if (IS_INCLUDE_URL(pInfo->imageInfo.imageMIMEType))
}
if (pInfo->tagInfo[AV_ID3TAG_TRACKNUM].marked == false) {
- pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value = mmfile_malloc(ID3TAG_V110_TRACK_NUM_DIGIT);
- if (pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value != NULL) {
- pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value[ID3TAG_V110_TRACK_NUM_DIGIT - 1] = 0;
- snprintf(pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value, ID3TAG_V110_TRACK_NUM_DIGIT, "%04d", (int)buffer[126]);
- pInfo->tagInfo[AV_ID3TAG_TRACKNUM].length = strlen(pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value);
+ pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value = g_malloc0(ID3TAG_V110_TRACK_NUM_DIGIT);
+ pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value[ID3TAG_V110_TRACK_NUM_DIGIT - 1] = 0;
+ snprintf(pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value, ID3TAG_V110_TRACK_NUM_DIGIT, "%04d", (int)buffer[126]);
+ pInfo->tagInfo[AV_ID3TAG_TRACKNUM].length = strlen(pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value);
- debug_msg(RELEASE, "pInfo->pTrackNum returned =(%s), pInfo->tracknumLen(%d)\n", pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value, pInfo->tagInfo[AV_ID3TAG_TRACKNUM].length);
- }
+ debug_msg(RELEASE, "pInfo->pTrackNum returned =(%s), pInfo->tracknumLen(%d)\n", pInfo->tagInfo[AV_ID3TAG_TRACKNUM].value, pInfo->tagInfo[AV_ID3TAG_TRACKNUM].length);
}
if (pInfo->tagInfo[AV_ID3TAG_GENRE].marked == false) {
realCpyFrameNum = purelyFramelen - encodingOffSet;
mmfile_free(pExtContent);
- pExtContent = mmfile_malloc(realCpyFrameNum + 3);
-
- if (pExtContent == NULL) {
- debug_error(DEBUG, "out of memory for pExtContent\n");
- continue;
- }
-
- memset(pExtContent, '\0', realCpyFrameNum + 3);
+ pExtContent = g_malloc0(realCpyFrameNum + 3);
memcpy(pExtContent, &buffer[curPos - purelyFramelen + encodingOffSet], purelyFramelen - encodingOffSet);
if (encodingOffSet < purelyFramelen) {
realCpyFrameNum = purelyFramelen - encodingOffSet;
- pExtContent = mmfile_malloc(realCpyFrameNum + 3);
-
- if (pExtContent == NULL) {
- debug_msg(DEBUG, "pExtContent malloc failed\n");
- continue;
- }
-
- memset(pExtContent, '\0', realCpyFrameNum + 3);
+ pExtContent = g_malloc0(realCpyFrameNum + 3);
if (textEncodingType != AV_ID3V2_UTF16 && textEncodingType != AV_ID3V2_UTF16_BE) {
if (CompTmp[0] == 'T' || (strcmp(CompTmp, "APIC") == 0)) {
if (encodingOffSet < purelyFramelen) {
realCpyFrameNum = purelyFramelen - encodingOffSet;
- pExtContent = mmfile_malloc(realCpyFrameNum + 3);
-
- if (pExtContent == NULL) {
- debug_error(DEBUG, "out of memoryu for id3tag parse\n");
- continue;
- }
-
- memset(pExtContent, '\0', realCpyFrameNum + 3);
+ pExtContent = g_malloc0(realCpyFrameNum + 3);
if (textEncodingType != AV_ID3V2_UTF16 && textEncodingType != AV_ID3V2_UTF16_BE) {
if (CompTmp[0] == 'T' || (strcmp(CompTmp, "APIC") == 0)) {
projects / platform / core / multimedia / libmm-fileinfo.git / commitdiff