wmvhdparser.cpp

sigmadesign smp8623 gui source code ,bingo

		RMDBGLOG((GUIPARSERDBG, "Could not read top of image (ParseImage) ... error\n"));
		goto invalidBitmap;
	}
	else {
		RMasciiToUInt16 (str, &(bitmap->object.y));
	}

	str = pnode->Attribute(XMLZINDEX_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read zIndex of image (ParseImage) ... default to 0\n"));
		bitmap->object.zIndex = 0;
	}
	else {
		RMasciiToUInt8 (str, &(bitmap->object.zIndex));
	}

	// set visibility -- not defined in WMHD xml
	bitmap->object.visible = TRUE;
		
	str = pnode->Attribute(XMLTRANSPARENTCOLOR_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read bitmap transparent color... ignoring\n"));
	}
	else {		
		if((str[0] == '0') &&
		   (str[1] == 'x')) {
			// hexa
			RMasciiHexToUint64(str+2, &color);
			bitmap->object.transparentcolor = (RMuint32)color;			
		}
		else {
			RMasciiToUInt32 (str, &(bitmap->object.transparentcolor));
		}
	}
	
	str = pnode->Attribute(XMLUSETRANSPARENTCOLOR_NODE, true);
	if (str != (RMascii *)NULL) {
		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {
			bitmap->object.usetransparentcolor = TRUE;
		}
		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {
			bitmap->object.usetransparentcolor = FALSE;
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "Invalid usetransparentcolor value of bitmap ... error\n"));
			goto invalidBitmap;
		}	
	}
	else
		bitmap->object.usetransparentcolor = FALSE;
		
	str = pnode->Attribute(XMLEVENT_NODE, true);
	if (str == (RMascii *)NULL) {
//		RMDBGLOG((GUIPARSERDBG, "Could not read bitmap event (ParseEventBitmap) ... ignoring\n"));
	}
	else {
		bitmap->event = STRDUP(str);
	}
	
	// display param / condition go together
	str = pnode->Attribute(XMLDISPLAYCONDITION_NODE, true);
	if (str != (RMascii *)NULL) {
		RMasciiToUInt16 (str, &(bitmap->displayCondition));
	
		str = pnode->Attribute(XMLDISPLAYPARAMETER_NODE, true);
		if (str != (RMascii *)NULL) {
			bitmap->displayParameter = STRDUP(str);
		}
		else{
			bitmap->displayCondition = 0;
			bitmap->displayParameter = (RMascii*)NULL;
		}
	}
		
//	RMDBGLOG((GUIPARSERDBG, "Bitmap : name : %s, x=%d, y=%d, visible : %s\n",
//		  bitmap->name, bitmap->object.x, bitmap->object.y, bitmap->object.visible ? "TRUE":"FALSE"));

	// set id
	bitmap->id = BITMAP_IDMASK | m_nextBitmapId++;
	
	return bitmap;
 invalidBitmap:
	FreeBitmap(bitmap);
	return (guiBitmapType*)NULL;
}


void RMWmvHDParser::FreeBitmap(guiBitmapType *bitmap)
{
	if(bitmap == NULL)
		return;
	
	if(bitmap->name != (RMascii *)NULL){
		RFREE(bitmap->name);
		bitmap->name = NULL;
	}
	if(bitmap->object.file != (RMascii *)NULL){
		RFREE(bitmap->object.file);
		bitmap->object.file = NULL;
	}
	if(bitmap->event != (RMascii *)NULL){
		RFREE(bitmap->event);
		bitmap->event = NULL;
	}
	
	if(bitmap->displayParameter != (RMascii *)NULL){
		RFREE(bitmap->displayParameter);
		bitmap->displayParameter = NULL;
	}

	RFREE(bitmap);	
}



////////////////////////////////////////////////////////////////////////////////
// MEDIA OBJECTS
////////////////////////////////////////////////////////////////////////////////

RMstatus RMWmvHDParser::GetMediaFiles(guiMediaType *media[MAX_GUI_MEDIA], RMuint16 *nMediaFiles)
{
	if(m_nbMediaFiles){
		RMMemcpy(media, m_MediaFiles, sizeof(m_MediaFiles));
		*nMediaFiles = m_nbMediaFiles;
	}
	return RM_OK;
}


guiMediaType *RMWmvHDParser::ParseMediaFile(TiXmlElement *pnode)
{
	const RMascii *str;
	guiMediaType *media;
	TiXmlElement *ptempNode;

	media = (guiMediaType*) CALLOC(1, sizeof(guiMediaType));

	str = pnode->Attribute(XMLID_NODE, true);	// name
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read media id ... error\n"));
		goto invalidMedia;
	}
	else {
		media->name = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLSRC_NODE, true);	// file
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read media src ... error\n"));
		goto invalidMedia;
	}
	else {
		media->file = RMCatAscii(m_mountPoint, str, NULL);
		if(IsValidPath(media->file) == FALSE){
			if(RMFAILED(FindFile(media->file))){
				RMDBGLOG((GUIPARSERDBG, "Invalid path given for bitmap (ParseImage) ... error\n"));
				goto invalidMedia;
			}
		}
	}
	
	str = pnode->Attribute(XMLCANSKIP_NODE, true);
	if (str != (RMascii *)NULL) {
		if (RMCompareAsciiCaseInsensitively (str, "TRUE")) {
			media->canSkip = TRUE;
		}
		else if (RMCompareAsciiCaseInsensitively (str, "FALSE")) {
			media->canSkip = FALSE;
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "Invalid canskip value of media ... (Parse Media)\n"));
			goto invalidMedia;
		}	
	}
	else
		goto invalidMedia;
		
	str = pnode->Attribute(XMLWHENDONE_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read whenDone from media object ... error\n"));
		goto invalidMedia;
	}
	else {
		media->whenDone = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLDURATION_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read media object duration... setting to 10 secs\n"));
		media->duration = 10;
	}
	else {
		media->duration = ConvertSMPTEtoSecs(str);
	}

	for(ptempNode = pnode->FirstChildElement(); ptempNode != NULL; ptempNode = ptempNode->NextSiblingElement()) {
       		str = ptempNode->Value();
		if (str == (RMascii *)NULL)
			continue;
		RMDBGLOG((GUIPARSERDBG, "node : %s\n", (char*)str));
		if (RMCompareAsciiCaseInsensitively (str, XMLCHAPTER_NODE)) {
			media->chapters[media->nbChapters] = ParseChapter(ptempNode);
			if(media->chapters[media->nbChapters] != (guiChapterType*)NULL){
				media->nbChapters++;
			}			
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "unknown node [%s] in media\n", str));
		}
	}
	
	RMDBGLOG((GUIPARSERDBG, "Media object: name : %s, file: %s\n", media->name, media->file));
	
	// set id
	media->id = MEDIA_IDMASK | m_nbMediaFiles;
	       
	return media;
	
 invalidMedia:
	FreeMediaFile(media);
	return (guiMediaType*)NULL;
}


void RMWmvHDParser::FreeMediaFile(guiMediaType *media)
{
	if(media == NULL)
		return;
		
	if(media->name != (RMascii *)NULL){
		RFREE(media->name);
		media->name = NULL;
	}
	
	if(media->file != (RMascii *)NULL){
		RFREE(media->file);
		media->file = NULL;
	}
	
	if(media->whenDone != (RMascii *)NULL){
		RFREE(media->whenDone);
		media->whenDone = NULL;
	}

	for(RMuint16 i = 0; i < media->nbChapters; i++){
		FreeChapter(media->chapters[i]);
		media->chapters[i] = NULL;
	}

	RFREE(media);
}


////////////////////////////////////////////////////////////////////////////////
// MEDIA CHAPTERS
////////////////////////////////////////////////////////////////////////////////


guiChapterType *RMWmvHDParser::ParseChapter(TiXmlElement *pnode)
{
	const RMascii *str;
	guiChapterType *chapter;

	chapter = (guiChapterType*) CALLOC(1, sizeof(guiChapterType));
	
	str = pnode->Attribute(XMLID_NODE, true);	// name -- case free
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read name of chapter (ParseChapter) ... error\n"));
		goto invalidChapter;
	}
	else {
		chapter->name = STRDUP(str);
	}
	
	str = pnode->Attribute(XMLSTARTTIME_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read chapter starttime (ParseChapter) ... error\n"));
		goto invalidChapter;
	}
	else {
		chapter->startTime = ConvertSMPTEtoSecs(str);
		// initialize seekTime as startTime
		chapter->seekTime = chapter->startTime;
	}
		
	RMDBGLOG((GUIPARSERDBG, "Chapter : name : %s, startTime=%s\n",
		  chapter->name, chapter->startTime));

	// set id
	chapter->id = CHAPTER_IDMASK | m_nextChapterId++;
	
	return chapter;
	
 invalidChapter:
	FreeChapter(chapter);
	return (guiChapterType*)NULL;
}


void RMWmvHDParser::FreeChapter(guiChapterType *chapter)
{
	if(chapter == NULL)
		return;
	
	if(chapter->name != (RMascii *)NULL){
		RFREE(chapter->name);
		chapter->name = NULL;
	}
	
	RFREE(chapter);	
}


////////////////////////////////////////////////////////////////////////////////
// COMMANDS
////////////////////////////////////////////////////////////////////////////////

RMstatus RMWmvHDParser::GetCommands(guiCommandType *commands[MAX_GUI_COMMANDS], RMuint16 *nCommands)
{
	if(m_nbCommands){
		RMMemcpy(commands, m_Commands, sizeof(m_Commands));
	}
	*nCommands = m_nbCommands;			
	return RM_OK;
}


guiCommandType *RMWmvHDParser::AddCommand(RMascii* commandName, RMuint32 id)
{
	guiCommandType *cmd;

	cmd = (guiCommandType*) CALLOC(1, sizeof(guiCommandType));

	cmd->name = STRDUP(commandName);
	cmd->id = id;	

//	RMDBGLOG((GUIPARSERDBG, "Command : name : %s, value : %ld\n", 
//		  cmd->name, cmd->value));

	return cmd;
}


void RMWmvHDParser::FreeCommand(guiCommandType *cmd)
{
	if(cmd == NULL)
		return;
		
	if(cmd->name != (RMascii *)NULL){
		RFREE(cmd->name);
		cmd->name = NULL;
	}
	RFREE(cmd);	
}


///////////////////////////////////////////////////////////////////////////////

RMuint32 RMWmvHDParser::ConvertSMPTEtoSecs(const RMascii* str)
{
	unsigned int hours, mins, secs, frames;
	
	if(RMasciiLength(str) == RMasciiLength("hh:mm:ss.ff"))
		sscanf(str, "%02u:%02u:%02u.%02u", &hours, &mins, &secs, &frames);
	else if(RMasciiLength(str) == RMasciiLength("hh:mm:ss.f"))
		sscanf(str, "%02u:%02u:%02u.%u", &hours, &mins, &secs, &frames);
	else
		return 0;
		
	return (hours * 3600 + mins * 60 + secs);
}

RMbool RMWmvHDParser::IsValidPath(const RMascii* path)
{
	FILE *fp;
	
	// Open the prospective BITMAP file
	if ((fp = fopen(path, "rb")) != NULL){
		fclose(fp);
		return TRUE;
	}
	
	return FALSE;
}


RMstatus RMWmvHDParser::FindFile(RMascii* path)
{
	RMascii dir[256];
	RMascii name[256];
	DIR *d;
	struct dirent *c;
	RMbool found = FALSE;	
	RMuint16 length = RMasciiLength(path);
	RMuint16 position = 0;
	RMuint16 i, j;
	RMMemset(name, 0, sizeof(name));
	RMMemset(dir, 0, sizeof(dir));
	
	//printf("looking for case insensitive %s\n", path);
	
	// split name and directory to test them individually
	
	// find last slash ('/')
	for(i = 0; i < length; i++){
		if(path[i] == '/'){
			position = i;
			continue;
		}
	}
	
	for(i = position + 1, j = 0; i < length; i++, j++){
		name[j] = path[i];
	}
	
	if(name[0] == 0)
		return RM_ERROR;
		
	RMNCopyAscii(dir, path, position + 1);//length - RMasciiLength(name));
	
	d = opendir(dir);
	if(d == NULL){
		// directory does not exist, try to find it
		RMascii dirs[20][80];	// max 20 levels deep
		RMuint16 dirlength = RMasciiLength(dir);
		RMuint8 count = 0;
		RMascii tempdir[256];
			
		// get all directories in the path
		j = 0;
		// start after first '/'
		for(i = 1; i < dirlength; i++){
			if(dir[i] != '/')
				dirs[count][j++] = dir[i];
			else{
				dirs[count][j] = '\0';
				count++;
				if(count > 20)
					return RM_ERROR;
				j = 0;
			}
		}
		
		// build path one by one checking for errors and correcting them
		RMCopyAscii(tempdir, "/");
		RMAppendAscii(tempdir, dirs[0]);// add mnt and skip it from loop
		RMAppendAscii(tempdir, "/");
		RMCopyAscii(dir, tempdir);	// backup good directory
		for(i = 1; i < count; i++){
			RMAppendAscii(tempdir, dirs[i]);
			RMAppendAscii(tempdir, "/");
			d = opendir(tempdir);
			if(d != NULL){
				closedir(d);
				RMAppendAscii(dir, dirs[i]);
				RMAppendAscii(dir, "/");
				continue;
			}
			else{
				// current dir not found, open last good dir and look for it
				d = opendir(dir);
				if(d != NULL){
					found = FALSE;
					while((c = readdir(d))!= NULL){
						if(RMCompareAscii(c->d_name, ".") || RMCompareAscii(c->d_name, ".."))
							continue;
						else{
							// match directory with parent directory entries
							if(RMCompareAsciiCaseInsensitively(dirs[i], c->d_name)){
								// found a match, save it and stop this search
								RMAppendAscii(dir, c->d_name);
								RMAppendAscii(dir, "/");
								RMCopyAscii(tempdir, dir);
								found = TRUE;
								break;	
							}
						}
					}
					closedir(d);
					if(found == FALSE){
						// did not find directory, quit search completely
						return RM_ERROR;					
					}																		
				}
				else{
					// fs error, quit
					return RM_ERROR;
				}
			}
		}
		d = opendir(dir);
		if(d == NULL)
			return RM_ERROR;
	}
			
	// find file in good directory
	found = FALSE;
	RMASSERT(d != NULL);
	while((c = readdir(d))!= NULL){
		if(RMCompareAscii(c->d_name, ".") || RMCompareAscii(c->d_name, ".."))
			continue;
		else{
			// compare file name with directory entries
			if(RMCompareAsciiCaseInsensitively(name, c->d_name)){
				// bingo, save and jump out
				RMCopyAscii(name, c->d_name);
				found = TRUE;
				break;
			}
		}				
	}
	closedir(d);
		
	if(found){
		RMCopyAscii(path, dir);
		RMAppendAscii(path, name);
		//printf("found case insensitive %s\n", path);
		return RM_OK;
	}
				
	return RM_ERROR;
}