goto exception;
}
- formatContext->title = mmfile_strdup(aacinfo.title);
- formatContext->author = mmfile_strdup(aacinfo.author);
- formatContext->artist = mmfile_strdup(aacinfo.artist);
- formatContext->album = mmfile_strdup(aacinfo.album);
- formatContext->album_artist = mmfile_strdup(aacinfo.album_artist);
- formatContext->year = mmfile_strdup(aacinfo.year);
- formatContext->copyright = mmfile_strdup(aacinfo.copyright);
- formatContext->comment = mmfile_strdup(aacinfo.comment);
- formatContext->genre = mmfile_strdup(aacinfo.genre);
- formatContext->tagTrackNum = mmfile_strdup(aacinfo.tracknum);
- formatContext->composer = mmfile_strdup(aacinfo.composer);
- formatContext->classification = mmfile_strdup(aacinfo.classification);
- formatContext->rating = mmfile_strdup(aacinfo.rating); /*not exist rating tag in id3*/
- formatContext->conductor = mmfile_strdup(aacinfo.conductor);
- formatContext->artworkMime = mmfile_strdup(aacinfo.artworkMime);
+ formatContext->title = g_strdup(aacinfo.title);
+ formatContext->author = g_strdup(aacinfo.author);
+ formatContext->artist = g_strdup(aacinfo.artist);
+ formatContext->album = g_strdup(aacinfo.album);
+ formatContext->album_artist = g_strdup(aacinfo.album_artist);
+ formatContext->year = g_strdup(aacinfo.year);
+ formatContext->copyright = g_strdup(aacinfo.copyright);
+ formatContext->comment = g_strdup(aacinfo.comment);
+ formatContext->genre = g_strdup(aacinfo.genre);
+ formatContext->tagTrackNum = g_strdup(aacinfo.tracknum);
+ formatContext->composer = g_strdup(aacinfo.composer);
+ formatContext->classification = g_strdup(aacinfo.classification);
+ formatContext->rating = g_strdup(aacinfo.rating); /*not exist rating tag in id3*/
+ formatContext->conductor = g_strdup(aacinfo.conductor);
+ formatContext->artworkMime = g_strdup(aacinfo.artworkMime);
if (aacinfo.artwork) {
formatContext->artworkSize = aacinfo.artworkSize;
formatContext->artwork = mmfile_malloc(aacinfo.artworkSize);
filename += strlen(MMFILE_MEM_URI);
- splitedString = mmfile_strsplit(filename, ":");
- if (splitedString == NULL) {
- debug_error(DEBUG, "invalid param\n");
- return MMFILE_IO_FAILED;
- }
+ splitedString = g_strsplit(filename, ":", -1);
+ mm_file_retvm_if_fails(DEBUG, splitedString, MMFILE_IO_FAILED);
if (!splitedString[0] || !splitedString[1]) {
debug_error(DEBUG, "invalid param\n");
*handle = memHandle;
- if (splitedString) {
- mmfile_strfreev(splitedString);
- }
+ g_strfreev(splitedString);
return MMFILE_IO_SUCCESS;
exception:
-
- if (splitedString) {
- mmfile_strfreev(splitedString);
- }
+ g_strfreev(splitedString);
return MMFILE_IO_FAILED;
}
mmfile_free(formatContext->artworkMime);
if (codec_id == AV_CODEC_ID_MJPEG)
- formatContext->artworkMime = mmfile_strdup("image/jpeg");
+ formatContext->artworkMime = g_strdup("image/jpeg");
else if (codec_id == AV_CODEC_ID_PNG)
- formatContext->artworkMime = mmfile_strdup("image/png");
+ formatContext->artworkMime = g_strdup("image/png");
else if (codec_id == AV_CODEC_ID_BMP)
- formatContext->artworkMime = mmfile_strdup("image/bmp");
+ formatContext->artworkMime = g_strdup("image/bmp");
else
debug_error(DEBUG, "Unknown cover type: 0x%x\n", codec_id);
if (!g_ascii_strcasecmp(tag->key, "title")) {
MMFILE_SAFE_FREE(formatContext->title);
- formatContext->title = mmfile_strdup(tag->value);
+ formatContext->title = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "artist")) {
MMFILE_SAFE_FREE(formatContext->artist);
- formatContext->artist = mmfile_strdup(tag->value);
+ formatContext->artist = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "composer")) {
MMFILE_SAFE_FREE(formatContext->composer);
- formatContext->composer = mmfile_strdup(tag->value);
+ formatContext->composer = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "album")) {
MMFILE_SAFE_FREE(formatContext->album);
- formatContext->album = mmfile_strdup(tag->value);
+ formatContext->album = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "album_artist")) {
MMFILE_SAFE_FREE(formatContext->album_artist);
- formatContext->album_artist = mmfile_strdup(tag->value);
+ formatContext->album_artist = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "copyright")) {
MMFILE_SAFE_FREE(formatContext->copyright);
- formatContext->copyright = mmfile_strdup(tag->value);
+ formatContext->copyright = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "comment")) {
MMFILE_SAFE_FREE(formatContext->comment);
- formatContext->comment = mmfile_strdup(tag->value);
+ formatContext->comment = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "description")) {
MMFILE_SAFE_FREE(formatContext->description);
- formatContext->description = mmfile_strdup(tag->value);
+ formatContext->description = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "genre")) {
MMFILE_SAFE_FREE(formatContext->genre);
- formatContext->genre = mmfile_strdup(tag->value);
+ formatContext->genre = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "date")) {
MMFILE_SAFE_FREE(formatContext->year);
- formatContext->year = mmfile_strdup(tag->value);
+ formatContext->year = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "creation_time")) {
MMFILE_SAFE_FREE(formatContext->recDate);
- formatContext->recDate = mmfile_strdup(tag->value);
+ formatContext->recDate = g_strdup(tag->value);
} else if ((!g_ascii_strcasecmp(tag->key, "track")) || (!g_ascii_strcasecmp(tag->key, "tracknumber"))) {
MMFILE_SAFE_FREE(formatContext->tagTrackNum);
- formatContext->tagTrackNum = mmfile_strdup(tag->value);
+ formatContext->tagTrackNum = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "lyrics")) {
MMFILE_SAFE_FREE(formatContext->unsyncLyrics);
- formatContext->unsyncLyrics = mmfile_strdup(tag->value);
+ formatContext->unsyncLyrics = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "rotate")) { /*can be "90", "180", "270" */
MMFILE_SAFE_FREE(formatContext->rotate);
- formatContext->rotate = mmfile_strdup(tag->value);
+ formatContext->rotate = g_strdup(tag->value);
} else if (!g_ascii_strcasecmp(tag->key, "spherical-video")) {
ParseSpatialVideoMetadataFromXMLString(tag->value, formatContext);
} else if (!g_ascii_strcasecmp(tag->key, "metadata_block_picture")) {
filename += strlen(MMFILE_MEM_URI);
- splitedString = mmfile_strsplit(filename, ":");
- if (splitedString == NULL) {
- debug_error(DEBUG, "invalid param\n");
- return MMFILE_IO_FAILED;
- }
+ splitedString = g_strsplit(filename, ":", -1);
+ mm_file_retvm_if_fails(DEBUG, splitedString, MMFILE_IO_FAILED);
if (!splitedString[0] || !splitedString[1]) {
debug_error(DEBUG, "invalid param\n");
*handle = memHandle;
- if (splitedString) {
- mmfile_strfreev(splitedString);
- }
+ g_strfreev(splitedString);
return MMFILE_IO_SUCCESS;
exception:
-
- if (splitedString) {
- mmfile_strfreev(splitedString);
- }
+ g_strfreev(splitedString);
return MMFILE_IO_FAILED;
}
int format = -1;
char mimeType[MMFILE_MIMETYPE_MAX_LEN] = {0, };
char ffmpegFormatName[MMFILE_FILE_FMT_MAX_LEN] = {0, };
- char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0, };
char *urifilename = NULL;
AVFormatContext *pFormatCtx = NULL;
AVInputFormat *grab_iformat = NULL;
av_register_all();
- snprintf(tempURIBuffer, MMFILE_URI_MAX_LEN, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)data, datasize);
- urifilename = mmfile_strdup(tempURIBuffer);
- if (!urifilename) {
- debug_error(DEBUG, "error: uri is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
+ urifilename = g_strdup_printf("%s%u:%u", MMFILE_MEM_URI, (unsigned int)data, datasize);
mmfile_register_io_all();
if (formatContext->title == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->title = mmfile_strdup(taginfo.title);
+ formatContext->title = g_strdup(taginfo.title);
}
mmfile_free(taginfo.title);
}
(unsigned int *)&cnv_len);
if (formatContext->composer == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->composer = mmfile_strdup(taginfo.composer);
+ formatContext->composer = g_strdup(taginfo.composer);
}
mmfile_free(taginfo.composer);
}
(unsigned int *)&cnv_len);
if (formatContext->comment == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->comment = mmfile_strdup(taginfo.comment);
+ formatContext->comment = g_strdup(taginfo.comment);
}
mmfile_free(taginfo.comment);
}
(unsigned int *)&cnv_len);
if (formatContext->copyright == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->copyright = mmfile_strdup(taginfo.copyright);
+ formatContext->copyright = g_strdup(taginfo.copyright);
}
mmfile_free(taginfo.copyright);
}
if (isDone) {
if (!strncmp(imy_key_buffer, "NAME", 4)) {
mmfile_free(tags->title);
- tags->title = mmfile_strdup(imy_value_buffer);
+ tags->title = g_strdup(imy_value_buffer);
} else if (!strncmp(imy_key_buffer, "COMPOSER", 8)) {
mmfile_free(tags->composer);
- tags->composer = mmfile_strdup(imy_value_buffer);
+ tags->composer = g_strdup(imy_value_buffer);
} else if (!strncmp(imy_key_buffer, "COPYRIGHT", 9)) {
mmfile_free(tags->copyright);
- tags->copyright = mmfile_strdup(imy_value_buffer);
+ tags->copyright = g_strdup(imy_value_buffer);
}
memset(imy_key_buffer, 0x00, _MMFILE_IMY_KEY_BUFFER_LENGTH);
formatContext->title = mmfile_string_convert((const char *)info->title, tag_len, "UTF-8", locale, NULL, (unsigned int *)&cnv_len);
if (formatContext->title == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->title = mmfile_strdup(info->title);
+ formatContext->title = g_strdup(info->title);
}
}
formatContext->copyright = mmfile_string_convert((const char *)info->copyright, tag_len, "UTF-8", locale, NULL, (unsigned int *)&cnv_len);
if (formatContext->copyright == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->copyright = mmfile_strdup(info->copyright);
+ formatContext->copyright = g_strdup(info->copyright);
}
}
formatContext->comment = mmfile_string_convert((const char *)info->comment, tag_len, "UTF-8", locale, NULL, (unsigned int *)&cnv_len);
if (formatContext->comment == NULL) {
debug_warning(DEBUG, "failed to UTF8 convert.\n");
- formatContext->comment = mmfile_strdup(info->comment);
+ formatContext->comment = g_strdup(info->comment);
}
}
privateData = formatContext->privateFormatData;
- formatContext->title = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_TITLE].value);
- formatContext->artist = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_ARTIST].value);
- formatContext->copyright = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_COPYRIGHT].value);
- formatContext->comment = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_COMMENT].value);
- formatContext->album = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_ALBUM].value);
- formatContext->album_artist = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_ALBUM_ARTIST].value);
- formatContext->year = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_YEAR].value);
- formatContext->genre = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_GENRE].value);
- formatContext->tagTrackNum = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_TRACKNUM].value);
- formatContext->composer = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_COMPOSER].value);
- formatContext->classification = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_CONTENT_GROUP].value);
- formatContext->conductor = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_CONDUCTOR].value);
- formatContext->unsyncLyrics = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_UNSYNCLYRICS].value);
+ formatContext->title = g_strdup(privateData->tagInfo[AV_ID3TAG_TITLE].value);
+ formatContext->artist = g_strdup(privateData->tagInfo[AV_ID3TAG_ARTIST].value);
+ formatContext->copyright = g_strdup(privateData->tagInfo[AV_ID3TAG_COPYRIGHT].value);
+ formatContext->comment = g_strdup(privateData->tagInfo[AV_ID3TAG_COMMENT].value);
+ formatContext->album = g_strdup(privateData->tagInfo[AV_ID3TAG_ALBUM].value);
+ formatContext->album_artist = g_strdup(privateData->tagInfo[AV_ID3TAG_ALBUM_ARTIST].value);
+ formatContext->year = g_strdup(privateData->tagInfo[AV_ID3TAG_YEAR].value);
+ formatContext->genre = g_strdup(privateData->tagInfo[AV_ID3TAG_GENRE].value);
+ formatContext->tagTrackNum = g_strdup(privateData->tagInfo[AV_ID3TAG_TRACKNUM].value);
+ formatContext->composer = g_strdup(privateData->tagInfo[AV_ID3TAG_COMPOSER].value);
+ formatContext->classification = g_strdup(privateData->tagInfo[AV_ID3TAG_CONTENT_GROUP].value);
+ formatContext->conductor = g_strdup(privateData->tagInfo[AV_ID3TAG_CONDUCTOR].value);
+ formatContext->unsyncLyrics = g_strdup(privateData->tagInfo[AV_ID3TAG_UNSYNCLYRICS].value);
formatContext->syncLyrics = privateData->pSyncLyrics;
formatContext->syncLyricsNum = privateData->tagInfo[AV_ID3TAG_SYNCLYRICS].length;
- formatContext->recDate = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_RECDATE].value);
- formatContext->part_of_set = mmfile_strdup(privateData->tagInfo[AV_ID3TAG_PART_OF_SET].value);
+ formatContext->recDate = g_strdup(privateData->tagInfo[AV_ID3TAG_RECDATE].value);
+ 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);
formatContext->artworkSize = privateData->imageInfo.imageLen;
memcpy(formatContext->artwork, privateData->imageInfo.pImageBuf, privateData->imageInfo.imageLen);
if (strlen(privateData->imageInfo.imageMIMEType) > 0)
- formatContext->artworkMime = mmfile_strdup(privateData->imageInfo.imageMIMEType);
+ formatContext->artworkMime = g_strdup(privateData->imageInfo.imageMIMEType);
else if (strlen(privateData->imageInfo.imageExt) > 0) {
debug_msg(RELEASE, "ID3 tag V2 File");
- formatContext->artworkMime = mmfile_strdup(privateData->imageInfo.imageExt);
+ 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");
}
goto FILE_FORMAT_FAIL;
}
} else if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) {
- char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0, };
-
- 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(DEBUG, "error: uri is NULL\n");
- goto FILE_FORMAT_FAIL;
- }
+ *urifilename = g_strdup_printf("%s%lu:%u", MMFILE_MEM_URI, (unsigned long)fileSrc->memory.ptr, fileSrc->memory.size);
ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
/*////////////////////////////////////////////////////////////////////// */
/* STRING API // */
/*////////////////////////////////////////////////////////////////////// */
-char **mmfile_strsplit(const char *string, const char *delimiter);
-void mmfile_strfreev(char **str_array);
-int mmfile_util_wstrlen(unsigned short *wText);
-short *mmfile_swap_2byte_string(short *mszOutput, short *mszInput, int length);
char *mmfile_get_charset(const char *str);
char *mmfile_string_convert(const char *str, unsigned int len, const char *to_codeset, const char *from_codeset, gsize *bytes_read, unsigned int *bytes_written);
-char *mmfile_strdup(const char *str);
-
/*////////////////////////////////////////////////////////////////////// */
int *bytes_written,
const char *func,
unsigned int line);
-char *mmfile_strdup_debug(const char *str, const char *func, unsigned int line);
#define mmfile_malloc(size) mmfile_malloc_debug((size), __func__, __LINE__)
#define mmfile_calloc(nmemb, size) mmfile_calloc_debug((nmemb), (size), __func__, __LINE__)
#define mmfile_memcpy(dest, src, n) mmfile_memcpy_debug((ptr), (src), (n), __func__, __LINE__)
#define mmfile_string_convert(str, len, to_codeset, from_codeset, bytes_read, bytes_written) mmfile_string_convert_debug((str), (len), (to_codeset), (from_codeset), (bytes_read), (bytes_written), __func__, __LINE__)
-#define mmfile_strdup(x) mmfile_strdup_debug((x), __func__, __LINE__)
#else
/*////////////////////////////////////////////////////////////////////// */
/* MEMORY API // */
debug_msg(RELEASE, "[%s]\n", filename);
- pHandle->fileName = mmfile_strdup(filename);
- if (!pHandle->fileName) {
- debug_error(DEBUG, "mmfile_malloc: pHandle->fileName\n");
- err = MMFILE_IO_FAILED;
- goto fail;
- }
+ pHandle->fileName = g_strdup(filename);
err = Func->mmfile_open(pHandle, filename, flags);
if (err < 0) {
filename += strlen(handle->iofunc->handleName) + 3; /* ://%d:%d means (memory addr:mem size)*/
- splitedString = mmfile_strsplit(filename, ":");
- if (splitedString == NULL) {
- debug_error(DEBUG, "invalid param\n");
- return MMFILE_IO_FAILED;
- }
+ splitedString = g_strsplit(filename, ":", -1);
+ mm_file_retvm_if_fails(DEBUG, splitedString, MMFILE_IO_FAILED);
if (!splitedString[0] || !splitedString[1]) {
debug_error(DEBUG, "invalid param\n");
handle->privateData = (void *) memHandle;
- if (splitedString) {
- mmfile_strfreev(splitedString);
- }
+ g_strfreev(splitedString);
return MMFILE_IO_SUCCESS;
exception:
-
- if (splitedString) {
- mmfile_strfreev(splitedString);
- }
-
-#if 0 /*dead code */
- mmfile_free(memHandle);
-#endif
+ g_strfreev(splitedString);
return MMFILE_IO_FAILED;
}
#include "mm_file_utils.h"
#ifdef __MMFILE_MEM_TRACE__
-short __WmLngSwapShort(short aShort)
-{
- return ((aShort << 8) + (aShort >> 8));
-}
-
-EXPORT_API
-short *mmfile_swap_2byte_string(short *mszOutput, short *mszInput, int length)
-{
- int i;
-
- for (i = 0; i < length; i++) {
- if (mszInput[i] == 0)
- break;
-
- mszOutput[i] = __WmLngSwapShort(mszInput[i]);
- }
-
- mszOutput[i] = 0;
-
- return mszOutput;
-}
-
-
EXPORT_API
char *mmfile_string_convert_debug(const char *str, unsigned int len,
const char *to_codeset, const char *from_codeset,
}
-EXPORT_API
-char *mmfile_strdup_debug(const char *str, const char *func, unsigned int line)
-{
- char *temp = NULL;
-
- if (!str)
- return NULL;
-
- temp = strdup(str);
-
- if (temp) {
- debug_msg(RELEASE, "## DEBUG ## %p = strdup (%p) by %s() %d\n", temp, str, func, line);
- }
-
- return temp;
-}
-
-
#else /* __MMFILE_MEM_TRACE__ */
EXPORT_API
/*if both to_codeset and from_codeset are same, return duplicated string.*/
if (g_strcmp0(to_codeset, from_codeset) == 0) {
result = g_strdup(str);
- if (!result) {
- debug_error(DEBUG, "g_strdup return null");
- return NULL;
- }
+
if (bytes_written != NULL)
*bytes_written = strlen(result);
return result;
}
-EXPORT_API
-char *mmfile_strdup(const char *str)
-{
- if (!str)
- return NULL;
-
- return strdup(str);
-}
-
#endif /*__MMFILE_MEM_TRACE__*/
-
-EXPORT_API
-int mmfile_util_wstrlen(unsigned short *wText)
-{
- int n = 0;
-
- if (NULL == wText) {
- debug_error(DEBUG, "wText is NULL\n");
- return MMFILE_UTIL_FAIL;
- }
-
- n = 0;
-
- while (*(wText + n) != 0) {
- n++;
- }
-
- return n;
-}
-
-EXPORT_API
-char **mmfile_strsplit(const char *string, const char *delimiter)
-{
- return g_strsplit(string, delimiter, -1);
-}
-
-EXPORT_API
-void mmfile_strfreev(char **str_array)
-{
- g_strfreev(str_array);
-}
unsigned int bytes_written = 0;
temp_text = mmfile_string_convert((const char *)&texttag.text[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup((const char *)texttag.text);
+ temp_text = g_strdup((const char *)texttag.text);
}
switch (eTag) {
yearbox.year = mmfile_io_be_int16(yearbox.year);
snprintf(temp_year, MAX_YEAR_BUFFER, "%d", yearbox.year);
temp_year[MAX_YEAR_BUFFER - 1] = '\0';
- formatContext->year = mmfile_strdup((const char *)temp_year);
+ formatContext->year = g_strdup((const char *)temp_year);
}
mmfile_seek(fp, basic_header->start_offset + basic_header->size, SEEK_SET);
unsigned int bytes_written = 0;
temp_text = mmfile_string_convert((const char *)&albumbox.albumtile[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup((const char *)albumbox.albumtile);
+ temp_text = g_strdup((const char *)albumbox.albumtile);
}
if (!formatContext->album)
char tracknum[10] = {0, };
snprintf(tracknum, 10, "%d", albumbox.trackNumber);
tracknum[9] = '\0';
- formatContext->tagTrackNum = mmfile_strdup((const char *)tracknum);
+ formatContext->tagTrackNum = g_strdup((const char *)tracknum);
}
}
unsigned int bytes_written = 0;
temp_text = mmfile_string_convert((const char *)&ratingTag.ratingInfo[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup((const char *)ratingTag.ratingInfo);
+ temp_text = g_strdup((const char *)ratingTag.ratingInfo);
}
if (!formatContext->rating) {
unsigned int bytes_written = 0;
temp_text = mmfile_string_convert((const char *)&classTag.classificationInfo[2], readed - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- temp_text = mmfile_strdup((const char *)classTag.classificationInfo);
+ temp_text = g_strdup((const char *)classTag.classificationInfo);
}
if (!formatContext->classification) {
if (p[0] == 0xFE && p[1] == 0xFF) {
lociTag.name = (unsigned char *)mmfile_string_convert((const char *)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- lociTag.name = (unsigned char *)mmfile_strdup((const char *)p);
+ lociTag.name = (unsigned char *)g_strdup((const char *)p);
}
} else {
goto exception;
if (p[0] == 0xFE && p[1] == 0xFF) {
lociTag.astronomical_body = (unsigned char *)mmfile_string_convert((const char *)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- lociTag.astronomical_body = (unsigned char *)mmfile_strdup((const char *)p);
+ lociTag.astronomical_body = (unsigned char *)g_strdup((const char *)p);
}
} else {
goto exception;
if (p[0] == 0xFE && p[1] == 0xFF) {
lociTag.additional_notes = (unsigned char *)mmfile_string_convert((const char *)(p + 2), pos - 2, "UTF-8", "UTF-16", NULL, (unsigned int *)&bytes_written);
} else {
- lociTag.additional_notes = (unsigned char *)mmfile_strdup((const char *)p);
+ lociTag.additional_notes = (unsigned char *)g_strdup((const char *)p);
}
} else {
goto exception;
if (!formatContext->tagTrackNum) {
memset(read_buf, 0x00, _ITUNES_READ_BUF_SZ);
snprintf((char *)read_buf, sizeof(read_buf), "%d", track_num);
- formatContext->tagTrackNum = mmfile_strdup((const char *)read_buf);
+ formatContext->tagTrackNum = g_strdup((const char *)read_buf);
}
}
}
memset(read_buf, 0x00, _ITUNES_READ_BUF_SZ);
snprintf((char *)read_buf, sizeof(read_buf), "%s", MpegAudio_Genre[genre_index - 1]);
debug_msg(RELEASE, "genre string=[%s] \n", read_buf);
- formatContext->genre = mmfile_strdup((const char *)read_buf);
+ formatContext->genre = g_strdup((const char *)read_buf);
}
}
}
formatContext->artwork = mmfile_malloc(cover_sz);
formatContext->artworkSize = cover_sz;
if (cover_type == _ITUNES_COVER_TYPE_JPEG) {
- formatContext->artworkMime = mmfile_strdup("image/jpeg");
+ formatContext->artworkMime = g_strdup("image/jpeg");
} else if (cover_type == _ITUNES_COVER_TYPE_PNG) {
- formatContext->artworkMime = mmfile_strdup("image/png");
+ formatContext->artworkMime = g_strdup("image/png");
/*} else if (cover_type == _ITUNES_COVER_TYPE_TIF) {
- formatContext->artworkMime = mmfile_strdup("image/tif");*/
+ formatContext->artworkMime = g_strdup("image/tif");*/
} else {
debug_warning(DEBUG, "Not proper cover image type, but set to jpeg. cover_type[%d]", cover_type);
- formatContext->artworkMime = mmfile_strdup("image/jpeg");
+ formatContext->artworkMime = g_strdup("image/jpeg");
}
if (formatContext->artwork) {
goto exception;
}
- formatContext->title = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_TITLE].value);
- formatContext->artist = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_ARTIST].value);
- formatContext->copyright = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_COPYRIGHT].value);
- formatContext->comment = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_COMMENT].value);
- formatContext->album = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_ALBUM].value);
- formatContext->album_artist = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_ALBUM_ARTIST].value);
- formatContext->year = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_YEAR].value);
- formatContext->genre = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_GENRE].value);
- formatContext->tagTrackNum = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_TRACKNUM].value);
- formatContext->composer = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_COMPOSER].value);
- formatContext->classification = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_CONTENT_GROUP].value);
- formatContext->conductor = mmfile_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_CONDUCTOR].value);
+ formatContext->title = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_TITLE].value);
+ formatContext->artist = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_ARTIST].value);
+ formatContext->copyright = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_COPYRIGHT].value);
+ formatContext->comment = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_COMMENT].value);
+ formatContext->album = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_ALBUM].value);
+ formatContext->album_artist = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_ALBUM_ARTIST].value);
+ formatContext->year = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_YEAR].value);
+ formatContext->genre = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_GENRE].value);
+ formatContext->tagTrackNum = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_TRACKNUM].value);
+ formatContext->composer = g_strdup((const char *)tagInfo.tagInfo[AV_ID3TAG_COMPOSER].value);
+ 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 (pInfo->genre > GENRE_COUNT - 1)
pInfo->genre = GENRE_COUNT - 1;
- pInfo->tagInfo[AV_ID3TAG_GENRE].value = mmfile_strdup(MpegAudio_Genre[pInfo->genre]);
+ pInfo->tagInfo[AV_ID3TAG_GENRE].value = g_strdup(MpegAudio_Genre[pInfo->genre]);
if (pInfo->tagInfo[AV_ID3TAG_GENRE].value)
pInfo->tagInfo[AV_ID3TAG_GENRE].length = strlen(pInfo->tagInfo[AV_ID3TAG_GENRE].value);
else
debug_msg(RELEASE, "genre size is Zero Or not UTF16 code! genreLen[%d] genre[%s]\n", pInfo->tagInfo[AV_ID3TAG_GENRE].length, pInfo->tagInfo[AV_ID3TAG_GENRE].value);
if (pInfo->tagInfo[AV_ID3TAG_GENRE].value)
- mpegAudioGenre = mmfile_strdup(pInfo->tagInfo[AV_ID3TAG_GENRE].value);
+ mpegAudioGenre = g_strdup(pInfo->tagInfo[AV_ID3TAG_GENRE].value);
else
pInfo->tagInfo[AV_ID3TAG_GENRE].length = 0;
if (idv2IntGenre > GENRE_COUNT - 1 || idv2IntGenre < 0)
idv2IntGenre = GENRE_COUNT - 1;
- pInfo->tagInfo[AV_ID3TAG_GENRE].value = mmfile_strdup(MpegAudio_Genre[idv2IntGenre]);
+ pInfo->tagInfo[AV_ID3TAG_GENRE].value = g_strdup(MpegAudio_Genre[idv2IntGenre]);
if (pInfo->tagInfo[AV_ID3TAG_GENRE].value)
pInfo->tagInfo[AV_ID3TAG_GENRE].length = strlen(pInfo->tagInfo[AV_ID3TAG_GENRE].value);
else
*/
/* Give space for NULL character. Hence added "+1" */
- pInfo->tagInfo[AV_ID3TAG_GENRE].value = mmfile_strdup(mpegAudioGenre);
+ pInfo->tagInfo[AV_ID3TAG_GENRE].value = g_strdup(mpegAudioGenre);
if (pInfo->tagInfo[AV_ID3TAG_GENRE].value)
pInfo->tagInfo[AV_ID3TAG_GENRE].length = strlen(pInfo->tagInfo[AV_ID3TAG_GENRE].value);
else
projects / platform / core / multimedia / libmm-fileinfo.git / commitdiff