AC_CONFIG_MACRO_DIR([m4])
# Checks for programs.
+m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
AC_PROG_CC
+AM_PROG_CC_C_O
AC_PROG_LIBTOOL
# Checks for libraries.
include/mm_file_format_ffmpeg_mem.h \
include/mm_file_format_ffmpeg.h \
include/mm_file_format_mmf.h \
- include/mm_file_format_mp3.h \
+ #include/mm_file_format_mp3.h \
include/mm_file_format_wav.h \
include/mm_file_format_private.h
int artistLen;
int authorLen;
int copyrightLen;
- int descriptionLen;
+ //int descriptionLen; /*ID3tag official tag name is "COMM" and meaning "Comment"*/
int commentLen;
int ratingLen;
int albumLen;
char *pArtist; //Lead performer(s)/Soloist(s),
char *pAuthor; //Author
char *pCopyright;
- char *pDescription;
- char *pComment; //Same to Description. Apps use Description. So replace this to Description for ID3V2 Tag
+ //char *pDescription; /*ID3tag official tag name is "COMM" and meaning "Comment"*/
+ char *pComment;
char *pRating;
char *pAlbum; //Album/Movie/
char *pYear;
if (pInfo->pArtist) mmfile_free (pInfo->pArtist);
if (pInfo->pAuthor) mmfile_free (pInfo->pAuthor);
if (pInfo->pCopyright) mmfile_free (pInfo->pCopyright);
- if (pInfo->pDescription) mmfile_free (pInfo->pDescription);
+ //if (pInfo->pDescription) mmfile_free (pInfo->pDescription);
if (pInfo->pComment) mmfile_free (pInfo->pComment);
if (pInfo->pRating) mmfile_free (pInfo->pRating);
if (pInfo->pAlbum) mmfile_free (pInfo->pAlbum);
bool mm_file_id3tag_parse_v224 (AvFileContentInfo* pInfo, unsigned char *buffer);
void mm_file_id3tag_restore_content_info (AvFileContentInfo* pInfo);
-
#ifdef __cplusplus
}
#endif
pData->tagInfo.album = hTag->pAlbum;
pData->tagInfo.year = hTag->pYear;
pData->tagInfo.copyright = hTag->pCopyright;
- pData->tagInfo.comment = hTag->pDescription;
+ pData->tagInfo.comment = hTag->pComment;
pData->tagInfo.genre = hTag->pGenre;
pData->tagInfo.tracknum = hTag->pTrackNum;
pData->tagInfo.composer = hTag->pComposer;
int idx = 0;
if(pFormatCtx != NULL) {
- for(idx = 0; idx < 3; idx++) {
+ for(idx = 0; idx < pFormatCtx->nb_streams + 1; idx++) {
AVDictionary *metainfo = NULL;
+ AVStream *st = NULL;
- if(idx == 0) { //Check metadata of Content
- if(pFormatCtx->metadata != NULL) {
- metainfo = pFormatCtx->metadata;
- } else {
- continue;
- }
- } else if(idx == 1) { //Check metadata of Video stream
- if (formatContext->videoStreamId != -1) {
- AVStream *st = pFormatCtx->streams[formatContext->videoStreamId];
+ if(idx < pFormatCtx->nb_streams) { //Check metadata of normal stream like audio, video, video cover art(cover art saved in new stream). refer to mov_read_covr() in ffmpeg.
+ st = pFormatCtx->streams[idx];
if(st != NULL)
metainfo = st->metadata;
+ } else { //Check metadata of Content
+ if(pFormatCtx->metadata != NULL) {
+ metainfo = pFormatCtx->metadata;
} else {
continue;
}
- } else if(idx == 2) { //Check metadata of Audio stream
- if (formatContext->audioStreamId != -1) {
- AVStream *st = pFormatCtx->streams[formatContext->audioStreamId];
- if(st != NULL)
- metainfo = st->metadata;
- } else {
- continue;
+ }
+
+ /*refer to mov_read_covr() in ffmpeg.*/
+ if(st != NULL) {
+ AVPacket pkt = st->attached_pic;
+ int codec_id = st->codec->codec_id;
+
+ if((pkt.data != NULL) && (pkt.size > 0)) {
+ /*Set mime type*/
+ if (formatContext->artworkMime) mmfile_free (formatContext->artworkMime);
+
+ if(codec_id == AV_CODEC_ID_MJPEG)
+ formatContext->artworkMime = mmfile_strdup("image/jpeg");
+ else if(codec_id == AV_CODEC_ID_PNG)
+ formatContext->artworkMime = mmfile_strdup("image/png");
+ 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);
+
+ /*Copy artwork*/
+ if (formatContext->artwork) mmfile_free (formatContext->artwork);
+
+ formatContext->artworkSize = pkt.size;
+ formatContext->artwork = mmfile_malloc (pkt.size);
+ memcpy (formatContext->artwork, pkt.data, pkt.size);
}
- } else {
- metainfo = NULL;
}
if(metainfo != NULL) {
} else if(!strcasecmp(tag->key, "comment")) {
if (formatContext->comment) free (formatContext->comment);
formatContext->comment = mmfile_strdup (tag->value);
+ } else if(!strcasecmp(tag->key, "description")) {
+ if (formatContext->description) free (formatContext->description);
+ formatContext->description = mmfile_strdup (tag->value);
} else if(!strcasecmp(tag->key, "genre")) {
if (formatContext->genre) free (formatContext->genre);
formatContext->genre = mmfile_strdup (tag->value);
}
}
}
+#ifdef __MMFILE_TEST_MODE__
+ mmfile_format_print_tags (formatContext);
+#endif
}
}
#else
formatContext->tagTrackNum = mmfile_strdup (tracknum);
}
#endif
- #ifdef __MMFILE_TEST_MODE__
- mmfile_format_print_tags (formatContext);
- #endif
return MMFILE_FORMAT_SUCCESS;
}
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
+#include <mm_types.h>
#include "mm_debug.h"
#include "mm_file_formats.h"
#include "mm_file_utils.h"
+#include "mm_file_format_ffmpeg_mem.h"
#include "mm_file_format_frame.h"
#define MILLION 1000000
#ifdef MMFILE_FORMAT_DEBUG_DUMP
-static void _save_pgm (unsigned char *buf,int wrap, int xsize,int ysize,char *filename);
+static void __save_frame(AVFrame *pFrame, int width, int height, int iFrame);
+
+void __save_frame(AVFrame *pFrame, int width, int height, int iFrame) {
+ FILE *pFile;
+ char szFilename[32];
+ int y;
+ // Open file
+ sprintf(szFilename, "frame%d.ppm", iFrame);
+ pFile=fopen(szFilename, "wb");
+ if(pFile==NULL)
+ return;
+
+ // Write header
+ fprintf(pFile, "P6\n%d %d\n255\n", width, height);
+ // Write pixel data
+ for(y=0; y<height; y++)
+ fwrite(pFrame->data[0]+y*pFrame->linesize[0], 1, width*3, pFile);
+
+ // Close file
+ fclose(pFile);
+}
+#endif
-static void _save_pgm (unsigned char *buf,int wrap, int xsize,int ysize,char *filename)
+static int __getMimeType(int formatId, char *mimeType)
{
- FILE *f;
- int i;
-
- f = fopen(filename,"w");
- if (f) {
- fprintf (f,"P5\n%d %d\n%d\n",xsize,ysize,255);
- for (i = 0; i < ysize; i++)
- fwrite (buf + i * wrap, 1, xsize, f);
- fclose (f);
+ int ret = 0; /*default: success*/
+
+ switch(formatId) {
+ case MM_FILE_FORMAT_3GP:
+ case MM_FILE_FORMAT_MP4:
+ sprintf(mimeType,"video/3gpp");
+ break;
+ case MM_FILE_FORMAT_ASF:
+ case MM_FILE_FORMAT_WMA:
+ case MM_FILE_FORMAT_WMV:
+ sprintf(mimeType,"video/x-ms-asf");
+ break;
+ case MM_FILE_FORMAT_AVI:
+ sprintf(mimeType,"video/avi");
+ break;
+ case MM_FILE_FORMAT_OGG:
+ sprintf(mimeType,"video/ogg");
+ break;
+ case MM_FILE_FORMAT_REAL:
+ sprintf(mimeType,"video/vnd.rn-realvideo");
+ break;
+ case MM_FILE_FORMAT_AMR:
+ sprintf(mimeType,"audio/AMR");
+ break;
+ case MM_FILE_FORMAT_AAC:
+ sprintf(mimeType,"audio/aac");
+ break;
+ case MM_FILE_FORMAT_MP3:
+ sprintf(mimeType,"audio/mp3");
+ break;
+ case MM_FILE_FORMAT_AIFF:
+ case MM_FILE_FORMAT_WAV:
+ sprintf(mimeType,"audio/wave");
+ break;
+ case MM_FILE_FORMAT_MID:
+ sprintf(mimeType,"audio/midi");
+ break;
+ case MM_FILE_FORMAT_MMF:
+ sprintf(mimeType,"audio/mmf");
+ break;
+ case MM_FILE_FORMAT_DIVX:
+ sprintf(mimeType,"video/divx");
+ break;
+ case MM_FILE_FORMAT_IMELODY:
+ sprintf(mimeType,"audio/iMelody");
+ break;
+ case MM_FILE_FORMAT_JPG:
+ sprintf(mimeType,"image/jpeg");
+ break;
+ case MM_FILE_FORMAT_AU:
+ sprintf(mimeType,"audio/basic");
+ break;
+ case MM_FILE_FORMAT_VOB:
+ sprintf(mimeType,"video/mpeg");
+ break;
+ case MM_FILE_FORMAT_FLV:
+ sprintf(mimeType,"video/x-flv");
+ break;
+ case MM_FILE_FORMAT_QT:
+ sprintf(mimeType,"video/quicktime");
+ break;
+ case MM_FILE_FORMAT_MATROSKA:
+ sprintf(mimeType,"video/x-matroska");
+ break;
+ case MM_FILE_FORMAT_FLAC:
+ sprintf(mimeType,"audio/x-flac");
+ break;
+ default:
+ ret = -1;
}
+
+ debug_msg ("id: %d, mimetype: %s\n", formatId, mimeType);
+
+ return ret;
}
-#endif
+static int __get_fileformat(const char *urifilename, int *format)
+{
+ int index;
+
+ debug_error("%s\n", urifilename);
+
+ for (index = 0; index < MM_FILE_FORMAT_NUM; index++) {
+ debug_msg ("search index = [%d]\n", index);
+ switch (index) {
+ case MM_FILE_FORMAT_QT:
+ case MM_FILE_FORMAT_3GP:
+ case MM_FILE_FORMAT_MP4: {
+ if (MMFileFormatIsValidMP4 (urifilename)) {
+ *format = MM_FILE_FORMAT_3GP;
+ return MMFILE_FORMAT_SUCCESS;
+ }
+ break;
+ }
-int mmfile_format_get_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
+ case MM_FILE_FORMAT_ASF:
+ case MM_FILE_FORMAT_WMA:
+ case MM_FILE_FORMAT_WMV: {
+ if (MMFileFormatIsValidASF (urifilename)) {
+ *format = MM_FILE_FORMAT_ASF;
+ return MMFILE_FORMAT_SUCCESS;
+ }
+ break;
+ }
+
+ case MM_FILE_FORMAT_DIVX:
+ case MM_FILE_FORMAT_AVI: {
+ if (MMFileFormatIsValidAVI(urifilename)) {
+ *format = MM_FILE_FORMAT_AVI;
+ return MMFILE_FORMAT_SUCCESS;
+ }
+ break;
+ }
+
+ case MM_FILE_FORMAT_MATROSKA: {
+ if (MMFileFormatIsValidMatroska (urifilename)) {
+ *format = MM_FILE_FORMAT_MATROSKA;
+ return MMFILE_FORMAT_SUCCESS;
+ }
+ break;
+ }
+
+ case MM_FILE_FORMAT_FLV: {
+ if (MMFileFormatIsValidFLV (urifilename)) {
+ *format = MM_FILE_FORMAT_FLV;
+ return MMFILE_FORMAT_SUCCESS;
+ }
+ break;
+ }
+
+ /* this is not video file format */
+ case MM_FILE_FORMAT_OGG:
+ case MM_FILE_FORMAT_AMR:
+ case MM_FILE_FORMAT_AAC:
+ case MM_FILE_FORMAT_MP3:
+ case MM_FILE_FORMAT_WAV:
+ case MM_FILE_FORMAT_MID:
+ case MM_FILE_FORMAT_MMF:
+ case MM_FILE_FORMAT_IMELODY:
+ case MM_FILE_FORMAT_FLAC:
+ break;
+ /* not supported file */
+ case MM_FILE_FORMAT_NUT:
+ case MM_FILE_FORMAT_REAL:
+ case MM_FILE_FORMAT_AIFF:
+ case MM_FILE_FORMAT_AU:
+ case MM_FILE_FORMAT_VOB:
+ case MM_FILE_FORMAT_JPG:
+ break;
+ default: {
+ debug_error ("error: invaild format enum[%d]\n", index);
+ break;
+ }
+ }
+ }
+
+ if (index == MM_FILE_FORMAT_NUM) {
+ debug_error("Can't probe file type\n");
+ }
+
+ *format = -1;
+ return MMFILE_FORMAT_FAIL;
+}
+
+static int __mmfile_get_frame(AVFormatContext *pFormatCtx, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
+
int i = 0;
+ int len = 0;
int ret = MMFILE_FORMAT_SUCCESS;
int videoStream = -1;
+ int key_detected = 0;
int frameFinished = 0;
double pos = timestamp;
bool find = false ;
bool first_seek = true;
int64_t pts = 0;
- AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pVideoCodecCtx = NULL;
AVCodec *pVideoCodec = NULL;
AVFrame *pFrame = NULL, *pFrameRGB = NULL;
AVPacket packet;
- int len = 0;
- int key_detected = 0;
-
- if (!size || !width || !height) {
- return MMFILE_FORMAT_FAIL;
- }
-
- av_register_all();
-
- /* Open video file */
- if(avformat_open_input(&pFormatCtx, path, NULL, NULL) != 0) {
- debug_error("error : avformat_open_input failed");
- return MMFILE_FORMAT_FAIL; /* Couldn't open file */
- }
-
- if (!pFormatCtx) {
- debug_warning ("failed to find av stream. maybe corrupted data.\n");
- ret = MMFILE_FORMAT_FAIL;
- goto exception;
- }
/* Retrieve stream information */
#ifdef __MMFILE_FFMPEG_V100__
}
if(find && frameFinished) {
- #ifdef MMFILE_FORMAT_DEBUG_DUMP
- char pgm_name[256] = {0,};
- sprintf (pgm_name, "./key_%d.ppm", (int)pos/1000);
- _save_pgm (pFrame->data[0], pFrame->linesize[0], pVideoCodecCtx->width, pVideoCodecCtx->height, pgm_name);
- #endif
break;
}
}
}
#endif
+#ifdef MMFILE_FORMAT_DEBUG_DUMP
+ __save_frame(pFrameRGB, pVideoCodecCtx->width, pVideoCodecCtx->height, (int)(pos/1000));
+#endif
}
else
{
if (pFrame) av_free (pFrame);
if (pFrameRGB) av_free (pFrameRGB);
if (pVideoCodecCtx) avcodec_close(pVideoCodecCtx);
- /* Close video file */
- if (pFormatCtx) avformat_close_input(&pFormatCtx);
return MMFILE_FORMAT_SUCCESS;
if (pFrame) av_free (pFrame);
if (pFrameRGB) av_free (pFrameRGB);
if (pVideoCodecCtx) avcodec_close (pVideoCodecCtx);
+
+ return ret;
+}
+
+int mmfile_format_get_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
+{
+ int ret = MMFILE_FORMAT_SUCCESS;
+ AVFormatContext *pFormatCtx = NULL;
+
+ if (!size || !width || !height) {
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ av_register_all();
+
+ /* Open video file */
+ if(avformat_open_input(&pFormatCtx, path, NULL, NULL) != 0) {
+ debug_error("error : avformat_open_input failed");
+ return MMFILE_FORMAT_FAIL; /* Couldn't open file */
+ }
+
+ if (!pFormatCtx) {
+ debug_warning ("failed to find av stream. maybe corrupted data.\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ ret = __mmfile_get_frame(pFormatCtx, timestamp, is_accurate, frame, size, width, height);
+ if (ret == MMFILE_FORMAT_SUCCESS) {
+ return ret;
+ }
+
+exception:
+ /* Close video file */
+ if (pFormatCtx) avformat_close_input(&pFormatCtx);
+
+ return ret;
+ }
+
+int mmfile_format_get_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
+{
+ int ret = MMFILE_FORMAT_SUCCESS;
+ int format = -1;
+ char mimeType[MMFILE_MIMETYPE_MAX_LEN] = {0,};
+ char ffmpegFormatName[MMFILE_FILE_FMT_MAX_LEN] = {0,};
+ char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0,};
+ char *urifilename = NULL;
+ AVFormatContext *pFormatCtx = NULL;
+ AVInputFormat *grab_iformat = NULL;
+
+ if (!size || !width || !height) {
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ av_register_all();
+
+ sprintf (tempURIBuffer, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)data, datasize);
+ urifilename = mmfile_strdup (tempURIBuffer);
+ if (!urifilename) {
+ debug_error ("error: uri is NULL\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ mmfile_register_io_all();
+
+ ret = __get_fileformat(urifilename, &format);
+ if (ret != MMFILE_FORMAT_SUCCESS) {
+ debug_error ("error: file format is invalid\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+#ifdef __MMFILE_FFMPEG_V085__
+ ffurl_register_protocol(&MMFileMEMProtocol, sizeof (URLProtocol));
+#else
+ register_protocol (&MMFileMEMProtocol);
+#endif
+
+ if(__getMimeType(format,mimeType)< 0) {
+ debug_error ("error: Error in MIME Type finding\n");
+ return MMFILE_FORMAT_FAIL;
+ }
+
+ memset (ffmpegFormatName, 0x00, MMFILE_FILE_FMT_MAX_LEN);
+
+ ret = mmfile_util_get_ffmpeg_format (mimeType,ffmpegFormatName);
+
+ if (MMFILE_UTIL_SUCCESS != ret) {
+ debug_error ("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");
+ goto exception;
+ }
+
+#ifdef __MMFILE_FFMPEG_V085__
+ ret = avformat_open_input (&pFormatCtx, urifilename, grab_iformat, NULL);
+#else
+ 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);
+ goto exception;
+ }
+
+ if (!pFormatCtx) {
+ debug_warning ("failed to find av stream. maybe corrupted data.\n");
+ ret = MMFILE_FORMAT_FAIL;
+ goto exception;
+ }
+
+ ret = __mmfile_get_frame(pFormatCtx, timestamp, is_accurate, frame, size, width, height);
+ if (ret == MMFILE_FORMAT_SUCCESS) {
+ return ret;
+ }
+
+exception:
/* Close video file */
if (pFormatCtx) avformat_close_input(&pFormatCtx);
if (privateData->pArtist) formatContext->artist = mmfile_strdup(privateData->pArtist);
if (privateData->pAuthor) formatContext->author = mmfile_strdup(privateData->pAuthor);
if (privateData->pCopyright) formatContext->copyright = mmfile_strdup(privateData->pCopyright);
- if (privateData->pDescription) formatContext->comment = mmfile_strdup(privateData->pDescription);
+ if (privateData->pComment) formatContext->comment = mmfile_strdup(privateData->pComment);
if (privateData->pAlbum) formatContext->album = mmfile_strdup(privateData->pAlbum);
if (privateData->pYear) formatContext->year = mmfile_strdup(privateData->pYear);
if (privateData->pGenre) formatContext->genre = mmfile_strdup(privateData->pGenre);
debug_msg ( "**** Info #2 ****\n");
debug_msg ( "Author : %s\n", pInfo->pAuthor);
debug_msg ( "Copyright : %s\n", pInfo->pCopyright);
- debug_msg ( "Description : %s\n", pInfo->pDescription);
+ 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);
NULL,
};
-static int _CleanupFrameContext (MMFileFormatContext *formatContext)
+static int _CleanupFrameContext (MMFileFormatContext *formatContext, bool clean_all)
{
if (formatContext) {
- formatContext->ReadFrame = NULL;
- formatContext->ReadStream = NULL;
- formatContext->ReadTag = NULL;
- formatContext->Close = NULL;
- if (formatContext->title) mmfile_free(formatContext->title);
- if (formatContext->artist) mmfile_free(formatContext->artist);
+ if (formatContext->ReadStream) formatContext->ReadStream = NULL;
+ if (formatContext->ReadFrame) formatContext->ReadFrame = NULL;
+ if (formatContext->ReadTag) formatContext->ReadTag = NULL;
+ if (formatContext->Close) formatContext->Close = NULL;
+
+ if (formatContext->uriFileName) mmfile_free(formatContext->uriFileName);
+ if (formatContext->title) mmfile_free(formatContext->title);
+ if (formatContext->artist) mmfile_free(formatContext->artist);
if (formatContext->author) mmfile_free(formatContext->author);
- if (formatContext->composer) mmfile_free(formatContext->composer);
- if (formatContext->album) mmfile_free(formatContext->album);
- if (formatContext->year) mmfile_free(formatContext->year);
- if (formatContext->copyright) mmfile_free(formatContext->copyright);
+ if (formatContext->composer) mmfile_free(formatContext->composer);
+ if (formatContext->album) mmfile_free(formatContext->album);
+ if (formatContext->copyright) mmfile_free(formatContext->copyright);
+ if (formatContext->description) mmfile_free(formatContext->description);
if (formatContext->comment) mmfile_free(formatContext->comment);
- if (formatContext->genre) mmfile_free(formatContext->genre);
+ if (formatContext->genre) mmfile_free(formatContext->genre);
+ if (formatContext->classification) mmfile_free(formatContext->classification);
+ if (formatContext->year) mmfile_free(formatContext->year);
+ if (formatContext->recDate) mmfile_free(formatContext->recDate);
+ if (formatContext->tagTrackNum) mmfile_free(formatContext->tagTrackNum);
+ if (formatContext->rating) mmfile_free(formatContext->rating);
+ if (formatContext->artworkMime) mmfile_free(formatContext->artworkMime);
if (formatContext->artwork) mmfile_free(formatContext->artwork);
- if (formatContext->classification) mmfile_free(formatContext->classification);
- if (formatContext->conductor) mmfile_free(formatContext->conductor);
+ if (formatContext->conductor) mmfile_free(formatContext->conductor);
+ if (formatContext->unsyncLyrics) mmfile_free(formatContext->unsyncLyrics);
+ if (formatContext->rotate) mmfile_free(formatContext->rotate);
+
+ if(clean_all) //syncLyrics has to be freed in mm_file_destroy_tag_attrs() except abnormal status
+ if (formatContext->syncLyrics) mm_file_free_synclyrics_list(formatContext->syncLyrics);
if (formatContext->privateFormatData) mmfile_free(formatContext->privateFormatData);
if (formatContext->privateCodecData) mmfile_free(formatContext->privateCodecData);
-
if (formatContext->nbStreams > 0) {
int i = 0;
for (i = 0; (i < formatContext->nbStreams) && (i < MAXSTREAMS); i++) {
mmfile_free (formatContext->thumbNail);
}
-
- formatContext->title = NULL;
- formatContext->artist = NULL;
- formatContext->author = NULL;
- formatContext->composer = NULL;
- formatContext->album = NULL;
- formatContext->copyright = NULL;
- formatContext->comment = NULL;
- formatContext->genre = NULL;
- formatContext->artwork = NULL;
-
- formatContext->privateFormatData = NULL;
- formatContext->privateCodecData = NULL;
- formatContext->classification = NULL;
-
- formatContext->videoTotalTrackNum = 0;
- formatContext->audioTotalTrackNum = 0;
-
- formatContext->nbStreams = 0;
- formatContext->streams[MMFILE_AUDIO_STREAM] = NULL;
- formatContext->streams[MMFILE_VIDEO_STREAM] = NULL;
- formatContext->thumbNail = NULL;
}
+
return MMFILE_FORMAT_SUCCESS;
}
}
-static int _mmfile_format_close (MMFileFormatContext *formatContext)
+static int _mmfile_format_close (MMFileFormatContext *formatContext, bool clean_all)
{
if (NULL == formatContext) {
debug_error ("error: invalid params\n");
formatContext->Close = NULL;
}
- if (formatContext->ReadFrame) formatContext->ReadFrame = NULL;
- if (formatContext->ReadStream) formatContext->ReadStream = NULL;
- if (formatContext->ReadTag) formatContext->ReadTag = NULL;
- if (formatContext->Close) formatContext->Close = NULL;
-
- if (formatContext->uriFileName) mmfile_free(formatContext->uriFileName);
- if (formatContext->title) mmfile_free(formatContext->title);
- if (formatContext->artist) mmfile_free(formatContext->artist);
- if (formatContext->author) mmfile_free(formatContext->author);
- if (formatContext->copyright) mmfile_free(formatContext->copyright);
- if (formatContext->comment) mmfile_free(formatContext->comment);
- if (formatContext->album) mmfile_free(formatContext->album);
- if (formatContext->year) mmfile_free(formatContext->year);
- if (formatContext->genre) mmfile_free(formatContext->genre);
- if (formatContext->composer) mmfile_free(formatContext->composer);
- if (formatContext->classification) mmfile_free(formatContext->classification);
- if (formatContext->artwork) mmfile_free(formatContext->artwork);
- if (formatContext->conductor) mmfile_free(formatContext->conductor);
- if (formatContext->unsyncLyrics) mmfile_free(formatContext->unsyncLyrics);
- if (formatContext->syncLyrics) mm_file_free_synclyrics_list(formatContext->syncLyrics);
- if (formatContext->artworkMime) mmfile_free(formatContext->artworkMime);
- if (formatContext->recDate) mmfile_free(formatContext->recDate);
-
- if (formatContext->privateFormatData) mmfile_free(formatContext->privateFormatData);
- if (formatContext->privateCodecData) mmfile_free(formatContext->privateCodecData);
-
- if (formatContext->nbStreams > 0) {
- int i = 0;
- for (i = 0; i < MAXSTREAMS; i++)
- if (formatContext->streams[i]) mmfile_free(formatContext->streams[i]);
- }
-
- if (formatContext->thumbNail) {
- if (formatContext->thumbNail->frameData)
- mmfile_free (formatContext->thumbNail->frameData);
-
- if (formatContext->thumbNail->configData)
- mmfile_free (formatContext->thumbNail->configData);
-
- mmfile_free (formatContext->thumbNail);
- }
+ _CleanupFrameContext(formatContext, clean_all);
if (formatContext)
mmfile_free (formatContext);
ret = MMFileOpenFunc[index] (formatObject);
if (MMFILE_FORMAT_FAIL == ret) {
- _CleanupFrameContext (formatObject);
+ _CleanupFrameContext (formatObject, true);
continue;
}
return MMFILE_FORMAT_SUCCESS;
exception:
- _mmfile_format_close (formatObject);
+ _mmfile_format_close (formatObject, true);
*formatContext = NULL;
return ret;
EXPORT_API
int mmfile_format_close (MMFileFormatContext *formatContext)
{
- if (NULL == formatContext) {
- debug_error ("error: invalid params\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- if (formatContext->Close) {
- formatContext->Close(formatContext);
- formatContext->Close = NULL;
- }
-
- if (formatContext->ReadFrame) formatContext->ReadFrame = NULL;
- if (formatContext->ReadStream) formatContext->ReadStream = NULL;
- if (formatContext->ReadTag) formatContext->ReadTag = NULL;
- if (formatContext->Close) formatContext->Close = NULL;
-
- if (formatContext->uriFileName) mmfile_free(formatContext->uriFileName);
-
- if (formatContext->title) mmfile_free(formatContext->title);
- if (formatContext->artist) mmfile_free(formatContext->artist);
- if (formatContext->author) mmfile_free(formatContext->author);
- if (formatContext->copyright) mmfile_free(formatContext->copyright);
- if (formatContext->comment) mmfile_free(formatContext->comment);
- if (formatContext->album) mmfile_free(formatContext->album);
- if (formatContext->year) mmfile_free(formatContext->year);
- if (formatContext->genre) mmfile_free(formatContext->genre);
- if (formatContext->composer) mmfile_free(formatContext->composer);
- if (formatContext->classification) mmfile_free(formatContext->classification);
- if (formatContext->artwork) mmfile_free(formatContext->artwork);
- if (formatContext->artworkMime) mmfile_free(formatContext->artworkMime);
- if (formatContext->tagTrackNum) mmfile_free(formatContext->tagTrackNum);
- if (formatContext->rating) mmfile_free(formatContext->rating);
- if (formatContext->conductor) mmfile_free(formatContext->conductor);
- if (formatContext->unsyncLyrics) mmfile_free(formatContext->unsyncLyrics);
- if (formatContext->recDate) mmfile_free(formatContext->recDate);
-
- if (formatContext->privateFormatData) mmfile_free(formatContext->privateFormatData);
- if (formatContext->privateCodecData) mmfile_free(formatContext->privateCodecData);
-
- if (formatContext->nbStreams > 0) {
- int i = 0;
- for (i = 0; i < MAXSTREAMS; i++)
- if (formatContext->streams[i]) mmfile_free(formatContext->streams[i]);
- }
-
- if (formatContext->thumbNail) {
- if (formatContext->thumbNail->frameData)
- mmfile_free (formatContext->thumbNail->frameData);
-
- if (formatContext->thumbNail->configData)
- mmfile_free (formatContext->thumbNail->configData);
-
- mmfile_free (formatContext->thumbNail);
- }
-
- if (formatContext)
- mmfile_free (formatContext);
-
- return MMFILE_FORMAT_SUCCESS;
+ return _mmfile_format_close(formatContext, false);
}
-
#define MM_FILE_TAG_COPYRIGHT "tag-copyright" /**< Copyright */
#define MM_FILE_TAG_DATE "tag-date" /**< Year */
#define MM_FILE_TAG_DESCRIPTION "tag-description" /**< Description */
+#define MM_FILE_TAG_COMMENT "tag-comment" /**< Comment */
#define MM_FILE_TAG_ARTWORK "tag-artwork" /**< Artwork */
#define MM_FILE_TAG_ARTWORK_SIZE "tag-artwork-size" /**< Artwork size */
#define MM_FILE_TAG_ARTWORK_MIME "tag-artwork-mime" /**< Artwork mime type */
int mm_file_get_video_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+int mm_file_get_video_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+
/**
@}
*/
#ifndef __MMFILE_DYN_LOADING__
int mmfile_format_get_frame(const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+
+int mmfile_format_get_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
#endif
char *composer;
char *album;
char *copyright;
+ char *description;
char *comment;
char *genre;
char *classification;
{"tag-copyright", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
{"tag-date", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
{"tag-description", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
+ {"tag-comment", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
{"tag-artwork", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_RW, (void *)NULL},
{"tag-artwork-size", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
{"tag-artwork-mime", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
int (*mmfile_codec_decode) (MMFileCodecContext *codecContext, MMFileCodecFrame *output);
int (*mmfile_codec_close) (MMFileCodecContext *codecContext);
int (*mmfile_format_get_frame) (const char* path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
+int (*mmfile_format_get_frame_from_memory) (const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
#endif
#ifdef __MMFILE_DYN_LOADING__
mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
if (formatContext->album) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM , formatContext->album);
if (formatContext->copyright) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COPYRIGHT, formatContext->copyright);
- if (formatContext->comment) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DESCRIPTION, formatContext->comment);
+ if (formatContext->description) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DESCRIPTION, formatContext->description);
+ if (formatContext->comment) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COMMENT, formatContext->comment);
if (formatContext->genre) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_GENRE, formatContext->genre);
if (formatContext->classification) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CLASSIFICATION, formatContext->classification);
if (formatContext->year) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DATE, formatContext->year);
parse.type = MM_FILE_PARSE_TYPE_ALL;
ret = _get_contents_info (attrs, &src, &parse);
-
-#ifdef __MMFILE_TEST_MODE__
if (ret != MM_ERROR_NONE) {
debug_error ("failed to get contents: %s\n", filename);
}
-#endif
*contents_attrs = (MMHandleType) attrs;
parse.type = MM_FILE_PARSE_TYPE_ALL;
ret = _get_contents_info (attrs, &src, &parse);
+ if (ret != MM_ERROR_NONE) {
+ debug_error ("failed to get contents");
+ }
*contents_attrs = (MMHandleType)attrs;
parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
ret = _get_contents_info (NULL, &src, &parse);
-#ifdef __MMFILE_TEST_MODE__
if (ret != MM_ERROR_NONE) {
debug_error ("failed to get stream info: %s\n", filename);
}
-#endif
/*set number of each stream*/
*audio_stream_num = parse.audio_track_num;
parse.type = MM_FILE_PARSE_TYPE_NORMAL;
ret = _get_contents_info (attrs, &src, &parse);
-
-#ifdef __MMFILE_TEST_MODE__
if (ret != MM_ERROR_NONE) {
debug_error ("failed to get contents: %s\n", filename);
}
-#endif
*contents_attrs = (MMHandleType) attrs;
if (formatFuncHandle) dlclose (formatFuncHandle);
return MM_ERROR_FILE_INTERNAL;
+}
+
+EXPORT_API
+int mm_file_get_video_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
+{
+ int ret = 0;
+ void *formatFuncHandle = NULL;
+ if (data == NULL) {
+ debug_error ("Invalid arguments [data is Null]\n");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+
+ if (datasize == 0) {
+ debug_error ("Invalid arguments [datasize is zero]\n");
+ return MM_ERROR_INVALID_ARGUMENT;
+ }
+
+#ifdef __MMFILE_DYN_LOADING__
+ /* Get from function argument */
+ formatFuncHandle = dlopen (MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
+ if (!formatFuncHandle) {
+ debug_error ("error : dlopen");
+ goto exception;
+ }
+
+ mmfile_format_get_frame_from_memory = dlsym (formatFuncHandle, "mmfile_format_get_frame_from_memory");
+ if ( !mmfile_format_get_frame_from_memory ) {
+ debug_error ("error : load library");
+ goto exception;
+ }
+#endif
+
+#ifdef __MMFILE_TEST_MODE__
+ debug_msg("data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);
+#endif
+
+ ret = mmfile_format_get_frame_from_memory(data, datasize, timestamp, is_accurate, frame, size, width, height);
+ if (ret == MMFILE_FORMAT_FAIL) {
+ debug_error ("error : get frame");
+ goto exception;
+ }
+
+ if (formatFuncHandle) dlclose (formatFuncHandle);
+
+ return MM_ERROR_NONE;
+
+exception:
+ if (formatFuncHandle) dlclose (formatFuncHandle);
+
+ return MM_ERROR_FILE_INTERNAL;
}
\ No newline at end of file
Name: libmm-fileinfo
Summary: Media Fileinfo
Version: 0.6.0
-Release: 14
+Release: 17
Group: System/Libraries
License: Apache License, Version 2.0
Source0: %{name}-%{version}.tar.gz
-Requires(post): /sbin/ldconfig
-Requires(postun): /sbin/ldconfig
-
BuildRequires: pkgconfig(mm-common)
BuildRequires: pkgconfig(mm-log)
BuildRequires: pkgconfig(libswscale)
mmfile_value_t date; //string
mmfile_value_t recdate; //string
mmfile_value_t description;
+ mmfile_value_t comment;
mmfile_value_t artwork; //data
mmfile_value_t artwork_size; //int
mmfile_value_t artwork_mime;
MM_FILE_TAG_DATE, &ctag.date.value.s_val, &ctag.date.len,
MM_FILE_TAG_RECDATE, &ctag.recdate.value.s_val, &ctag.recdate.len,
MM_FILE_TAG_DESCRIPTION, &ctag.description.value.s_val, &ctag.description.len,
+ MM_FILE_TAG_COMMENT, &ctag.comment.value.s_val, &ctag.comment.len,
MM_FILE_TAG_ARTWORK, &ctag.artwork.value.p_val, &ctag.artwork.len,
MM_FILE_TAG_ARTWORK_SIZE, &ctag.artwork_size.value.i_val,
MM_FILE_TAG_ARTWORK_MIME, &ctag.artwork_mime.value.s_val, &ctag.artwork_mime.len,
printf("# year: [%s]\n", ctag.date.value.s_val);
printf("# recdate: [%s]\n", ctag.recdate.value.s_val);
printf("# description: [%s]\n", ctag.description.value.s_val);
+ printf("# comment: [%s]\n", ctag.comment.value.s_val);
printf("# artwork: [%p]\n", ctag.artwork.value.p_val);
printf("# artwork_size: [%d]\n", ctag.artwork_size.value.i_val);
printf("# artwork_mime: [%s]\n", ctag.artwork_mime.value.s_val);
int authorLen;
int copyrightLen;
int descriptionLen;
-// int commentLen;
+ int commentLen;
int ratingLen;
int albumLen;
int yearLen;
char *pAuthor; //Author
char *pCopyright;
char *pDescription;
- char *pComment; //Same to Description. Apps use Description. So replace this to Description for ID3V2 Tag
+ char *pComment;
char *pRating;
char *pAlbum; //Album/Movie/
char *pYear;
if (pInfo->pURL) mmfile_free (pInfo->pURL);
if (pInfo->pOriginArtist) mmfile_free (pInfo->pOriginArtist);
if (pInfo->pComposer) mmfile_free (pInfo->pComposer);
+ if (pInfo->pUnsyncLyrics) mmfile_free (pInfo->pUnsyncLyrics);
if (pInfo->imageInfo.pImageBuf) mmfile_free (pInfo->imageInfo.pImageBuf);
if (strlen(pInfo->imageInfo.imageMIMEType)>0) memset(pInfo->imageInfo.imageMIMEType, 0, MP3_ID3_IMAGE_MIME_TYPE_MAX_LENGTH);
if (pInfo->pTransactionID) mmfile_free (pInfo->pTransactionID);
- if (pInfo->pUnsyncLyrics) mmfile_free (pInfo->pUnsyncLyrics);
+
}
}
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->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->composer) debug_msg ("composer = %s\n", in->composer);
if (in->album) debug_msg ("album = %s\n", in->album);
- if (in->copyright) debug_msg ("copyright = %s\n", in->copyright);
- if (in->comment) debug_msg ("comment = %s\n", in->comment);
+ 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->year) debug_msg ("year = %s\n", in->year);
if (in->recDate) debug_msg ("recDate = %s\n", in->recDate);
- debug_msg ("tagTrackNum = %d\n", in->tagTrackNum);
- 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->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);
}
}
#include "mm_debug.h"
#include "mm_file_utils.h"
-#define ENABLE_ITUNES_META
+//#define ENABLE_ITUNES_META //All itunes metadata extracted by ffmpeg. see mov_read_udta_string()
typedef struct _mmfilemp4basicboxheader {
unsigned int size;
break;
}
case eMMFILE_3GP_TAG_CAPTION: {
- if (!formatContext->comment) {
- formatContext->comment = temp_text;
+ if (!formatContext->description) {
+ formatContext->description = temp_text;
}
break;
}
if (!formatContext->artist) formatContext->artist = mmfile_strdup((const char*)tagInfo.pArtist);
if (!formatContext->author) formatContext->author = mmfile_strdup((const char*)tagInfo.pAuthor);
if (!formatContext->copyright) formatContext->copyright = mmfile_strdup((const char*)tagInfo.pCopyright);
- if (!formatContext->comment) formatContext->comment = mmfile_strdup((const char*)tagInfo.pDescription);
+ if (!formatContext->comment) formatContext->comment = mmfile_strdup((const char*)tagInfo.pComment);
if (!formatContext->album) formatContext->album = mmfile_strdup((const char*)tagInfo.pAlbum);
if (!formatContext->year) formatContext->year = mmfile_strdup((const char*)tagInfo.pYear);
if (!formatContext->genre) formatContext->genre = mmfile_strdup((const char*)tagInfo.pGenre);
#endif
}
if(pInfo->tagV2Info.bDescriptionMarked == false) {
- pInfo->pDescription = mmfile_string_convert ((const char*)&buffer[97], MP3_ID3_DESCRIPTION_LENGTH, "UTF-8", locale, NULL, (unsigned int*)&pInfo->descriptionLen);
+ 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->pDescription returned =(%s), pInfo->descriptionLen(%d)\n", pInfo->pDescription, pInfo->descriptionLen);
+ debug_msg ( "pInfo->pComment returned =(%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
#endif
}
if(textEncodingType == AV_ID3V2_UTF16)
{
- pInfo->pDescription = mmfile_string_convert ((char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", "UCS2", NULL, (unsigned int*)&pInfo->descriptionLen);
+ pInfo->pComment = mmfile_string_convert ((char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", "UCS2", NULL, (unsigned int*)&pInfo->commentLen);
}
else
{
- pInfo->pDescription = mmfile_string_convert ((char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", locale, NULL, (unsigned int*)&pInfo->descriptionLen);
+ pInfo->pComment = mmfile_string_convert ((char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", locale, NULL, (unsigned int*)&pInfo->commentLen);
}
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pDescription returned = (%s), pInfo->descriptionLen(%d)\n", pInfo->pDescription, pInfo->descriptionLen);
+ debug_msg ( "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
#endif
pInfo->tagV2Info.bDescriptionMarked = true;
}
else
{
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pDescription Never Get Here!!\n");
+ debug_msg ( "pInfo->pComment Never Get Here!!\n");
#endif
}
}
if(textEncodingType == AV_ID3V2_UTF16)
{
- pInfo->pDescription = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", "UCS2", NULL, (unsigned int*)&pInfo->descriptionLen);
+ pInfo->pComment = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", "UCS2", NULL, (unsigned int*)&pInfo->commentLen);
}
else if (textEncodingType == AV_ID3V2_UTF16_BE)
{
}
else
{
- pInfo->pDescription = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", locale, NULL, (unsigned int*)&pInfo->descriptionLen);
+ pInfo->pComment = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", locale, NULL, (unsigned int*)&pInfo->commentLen);
}
}
else
#ifdef __MMFILE_TEST_MODE__
debug_msg ( "failed to get Comment Info tmp(%d), purelyFramelen - encodingOffSet(%d)\n", tmp, purelyFramelen - encodingOffSet);
#endif
- pInfo->descriptionLen = 0;
+ pInfo->commentLen = 0;
}
}
else
#ifdef __MMFILE_TEST_MODE__
debug_msg ( "Description info too small to parse realCpyFrameNum(%d)\n", realCpyFrameNum);
#endif
- pInfo->descriptionLen = 0;
+ pInfo->commentLen = 0;
}
tmp = 0;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pDescription returned = (%s), pInfo->descriptionLen(%d)\n", pInfo->pDescription, pInfo->descriptionLen);
+ debug_msg ( "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
#endif
pInfo->tagV2Info.bDescriptionMarked = true;
}
else
{
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pDescription Never Get Here!!\n");
+ debug_msg ( "pInfo->pComment Never Get Here!!\n");
#endif
}
}
if(textEncodingType == AV_ID3V2_UTF16)
{
- pInfo->pDescription = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", "UCS2", NULL, (unsigned int*)&pInfo->descriptionLen);
+ pInfo->pComment = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", "UCS2", NULL, (unsigned int*)&pInfo->commentLen);
}
else if(textEncodingType == AV_ID3V2_UTF16_BE)
{
}
else if(textEncodingType == AV_ID3V2_UTF8)
{
- pInfo->pDescription= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
- memset(pInfo->pDescription, 0, (realCpyFrameNum+2));
- memcpy(pInfo->pDescription, pExtContent+tmp, realCpyFrameNum);
- pInfo->pDescription[realCpyFrameNum] = '\0';
+ pInfo->pComment= mmfile_malloc (realCpyFrameNum+2);//Ignore NULL char for UTF16
+ memset(pInfo->pComment, 0, (realCpyFrameNum+2));
+ memcpy(pInfo->pComment, pExtContent+tmp, realCpyFrameNum);
+ pInfo->pComment[realCpyFrameNum] = '\0';
/*string copy with '\0'*/
- pInfo->descriptionLen = realCpyFrameNum;
- _STRNCPY_EX (pInfo->pDescription, pExtContent, pInfo->descriptionLen);
+ pInfo->commentLen = realCpyFrameNum;
+ _STRNCPY_EX (pInfo->pComment, pExtContent, pInfo->commentLen);
}
else
{
- pInfo->pDescription = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", locale, NULL, (unsigned int*)&pInfo->descriptionLen);
+ pInfo->pComment = mmfile_string_convert ((const char*)&pExtContent[tmp], realCpyFrameNum, "UTF-8", locale, NULL, (unsigned int*)&pInfo->commentLen);
}
}
else
tmp = 0;
#ifdef __MMFILE_TEST_MODE__
- debug_msg ( "pInfo->pDescription returned = (%s), pInfo->descriptionLen(%d)\n", pInfo->pDescription, pInfo->descriptionLen);
+ debug_msg ( "pInfo->pComment returned = (%s), pInfo->commentLen(%d)\n", pInfo->pComment, pInfo->commentLen);
#endif
pInfo->tagV2Info.bDescriptionMarked = true;
}
projects / platform / core / multimedia / libmm-fileinfo.git / commitdiff