wmvhdparser.cpp

sigmadesign smp8623 gui source code ,bingo

/*****************************************
 Copyright  2001-2003  
 Sigma Designs, Inc. All Rights Reserved
 Proprietary and Confidential
 *****************************************/
#ifndef ALLOW_OS_CODE
#define ALLOW_OS_CODE 1
#endif //ALLOW_OS_CODE

#include "../common.h"
#include "wmvhdparser.h"
#include "guicommands.h"

#include <dirent.h>

// for ascii manipulation ... to be changed
#include "rmcore/include/rmcore.h"

#if 0
#define GUIPARSERDBG ENABLE
#else
#define GUIPARSERDBG DISABLE
#endif

#define WMVHD_ROOT	"disc"
#define WMVHD_XML	"disc.xml"
#define PAGE_START_ID	0
#define WMVHD_WIDTH	1280
#define WMVHD_HEIGHT	720

// set lower case for comparison
#define DISC_SETSUBTITLE	"setsubtitle"
#define DISC_SETAUDIOTRACK	"setaudiotrack"
#define DISC_SETMAINMENU	"setmainmenu"


RMWmvHDParser::RMWmvHDParser(RMascii* mountPoint)
	:  m_disc(NULL),
	   m_nbOsdPages(0),
	   m_nbMediaFiles(0),
	   m_nbCommands(0),
	   m_nextButtonId(0),
	   m_nextBitmapId(0),
	   m_nextChapterId(0)
{
	RMMemset((void*)m_osdPages, 0, MAX_GUI_PAGES * sizeof(guiOsdPageType*));
	RMMemset((void*)m_MediaFiles, 0, MAX_GUI_MEDIA * sizeof(guiMediaType*));
	RMMemset((void*)m_Commands, 0, MAX_GUI_COMMANDS * sizeof(guiCommandType*));
	RMMemset(&m_metadata, 0, sizeof(guiWmvHDMetadataType));
	RMMemset(m_mountPoint, 0, sizeof(m_mountPoint));
	
	m_screenFormat.width = WMVHD_WIDTH;
	m_screenFormat.height = WMVHD_HEIGHT;
	
	if(mountPoint != NULL)
		RMCopyAscii(m_mountPoint, mountPoint);	
}

RMWmvHDParser::~RMWmvHDParser()
{
	Close();
}

RMstatus RMWmvHDParser::DoParsing()
{ 
	RMstatus status = RM_OK;
	TiXmlElement* pnode = 0;
	
	RMascii *xmlFile = RMCatAscii(m_mountPoint, WMVHD_XML, NULL);
	
	TiXmlDocument doc(xmlFile);
	if(doc.LoadFile() == FALSE){
		fprintf(stderr, "Failed parsing %s in (row, col) (%d, %d)\n", xmlFile, doc.ErrorRow(), doc.ErrorCol());
		RFREE(xmlFile);
		return RM_ERROR;
	}
	
	pnode = doc.FirstChildElement("disc");
	
	if(pnode == NULL){
		RFREE(xmlFile);
		RMDBGLOG((GUIPARSERDBG, "failed to get root element [%s]\n", WMVHD_ROOT));	
		return RM_ERROR;
	}			
	
	m_disc = ParseDisc(pnode);
	if(m_disc == NULL)
		status = RM_ERROR;
		
	RFREE(xmlFile);

	return status;
}


RMstatus RMWmvHDParser::GetScreenFormat(guiScreenFormatType* screenFormat)
{
	RMMemcpy(screenFormat, &m_screenFormat, sizeof(guiScreenFormatType));
	return RM_OK;
}


RMstatus RMWmvHDParser::Close()
{
	if(m_disc != NULL){
		FreeDisc(m_disc);
		m_disc = NULL;
	}
	
	return RM_OK;
}

RMstatus RMWmvHDParser::GetPlayerParams(guiPlayerParams *params)
{
	if(m_disc->mainmediaID == NULL)
		return RM_ERROR;
		
	params->mainPage = m_disc->mainmenuID;
	return RM_OK;
}


////////////////////////////////////////////////////////////////////////////////
// DISC
////////////////////////////////////////////////////////////////////////////////


RMstatus RMWmvHDParser::GetDiscInfo(guiWmvHDDiscType *discInfo)
{
	RMMemcpy(discInfo, m_disc, sizeof(guiWmvHDDiscType));
	return RM_OK;
}


guiWmvHDDiscType* RMWmvHDParser::ParseDisc(TiXmlElement *pnode)
{
	guiWmvHDDiscType* disc;
	const RMascii *str;
	TiXmlElement *ptempNode;
	RMuint64 region;

	disc =(guiWmvHDDiscType*)CALLOC(1, sizeof(guiWmvHDDiscType));
	
	str = pnode->Attribute(XMLID_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read id (ParseDisc) ... error\n"));
		goto invalidDisc;
	}
	else {
		disc->name = STRDUP(str);
	}

	str = pnode->Attribute(XMLMAINMENUID_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read mainmenuID (ParseDisc) ... error\n"));
		goto invalidDisc;
	}
	else {
		disc->mainmenuID = STRDUP(str);
	}

	str = pnode->Attribute(XMLMAINMEDIAID_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read mainmediaID (ParseDisc) ... error\n"));
		goto invalidDisc;
	}
	else {
		disc->mainmediaID = STRDUP(str);		
	}

	str = pnode->Attribute(XMLREGION_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read region (ParseDisc) ... error\n"));
		goto invalidDisc;
	}
	else {
		if(str[0] == '0'){
			// hexa
			RMasciiHexToUint64(str+1, &region);
			disc->region = (region >> 20);
			if(disc->region > 8){
				disc->region = (region >> 24);
				if(disc->region > 8){
					RMDBGLOG((GUIPARSERDBG, "Invalid region value default to region 1\n"));
					goto invalidDisc;
				}				
			}
		}
		else{
			RMDBGLOG((GUIPARSERDBG, "Invalid region value default to region 1\n"));
			disc->region = 1;
		}	
	}

	str = pnode->Attribute(XMLDEFAULTLANGUAGE_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read defaultLanguage (ParseDisc) ... ignoring\n"));		
	}
	else {
		disc->defaultLanguage = STRDUP(str);
	}
		
	str = pnode->Attribute(XMLSTARTUPOBJECT_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read startupObject ... error\n"));
		goto invalidDisc;
	}
	else {
		disc->startupObject = STRDUP(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, (RMascii *)XMLMENUOBJECT_NODE)) {
			m_osdPages[m_nbOsdPages] = ParseOsdPage(ptempNode);
			if(m_osdPages[m_nbOsdPages] != (guiOsdPageType*)NULL){
				m_nbOsdPages++;
			}
		}
		else if (RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLMEDIAOBJECT_NODE)) {
			m_MediaFiles[m_nbMediaFiles] = ParseMediaFile(ptempNode);
			if(m_MediaFiles[m_nbMediaFiles] != (guiMediaType*)NULL){
				m_nbMediaFiles++;
			}
		}
		else if(RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLSUPPORTTEXT_NODE)) {
			SetMetadataValue(ptempNode, XMLSUPPORTTEXT_NODE);			
		}
		else if(RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLCONTENTDISTRIBUTOR_NODE)) {
			SetMetadataValue(ptempNode, XMLCONTENTDISTRIBUTOR_NODE);			
		}
		else if(RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLCOPYRIGHT_NODE)) {
			SetMetadataValue(ptempNode, XMLCOPYRIGHT_NODE);			
		}
		else if(RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLTITLE_NODE)) {
			SetMetadataValue(ptempNode, XMLTITLE_NODE);			
		}
		else if(RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLGENRE_NODE)) {
			SetMetadataValue(ptempNode, XMLGENRE_NODE);			
		}
		else if(RMCompareAsciiCaseInsensitively (str, (RMascii *)XMLDIRECTOR_NODE)) {
			SetMetadataValue(ptempNode, XMLDIRECTOR_NODE);			
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "unknown node [%s] in disc\n", str));
		}
	}
		
	RMDBGLOG((GUIPARSERDBG, "end disc\n"));
	return disc;

 invalidDisc:
	FreeDisc(disc);
	return (guiWmvHDDiscType*)NULL;
}


void RMWmvHDParser::FreeDisc(guiWmvHDDiscType *disc)
{
	if(disc == NULL)
		return;
		
	if(disc->name != (RMascii *)NULL){
		RFREE(disc->name);
		disc->name = NULL;
	}		
	
	if(disc->mainmenuID != (RMascii *)NULL){
		RFREE(disc->mainmenuID);
		disc->mainmenuID = NULL;
	}		
	
	if(disc->mainmediaID != (RMascii *)NULL){
		RFREE(disc->mainmediaID);
		disc->mainmediaID = NULL;
	}
	
	if(disc->defaultLanguage != (RMascii *)NULL){
		RFREE(disc->defaultLanguage);
		disc->defaultLanguage = NULL;
	}

	if(disc->startupObject != (RMascii *)NULL){
		RFREE(disc->startupObject);
		disc->startupObject = NULL;
	}
	
	for(RMuint16 i = 0; i < m_nbOsdPages; i++){
		FreeOsdPage(m_osdPages[i]);
		m_osdPages[i] = NULL;
	}

	for(RMuint16 i = 0; i < m_nbMediaFiles; i++){
		FreeMediaFile(m_MediaFiles[i]);
		m_MediaFiles[i] = NULL;
	}

	for(RMuint16 i = 0; i < m_nbCommands; i++){
		FreeCommand(m_Commands[i]);
		m_Commands[i] = NULL;
	}
	
	FreeMetadata();

	RFREE(disc);
}


////////////////////////////////////////////////////////////////////////////////
// METADATA
////////////////////////////////////////////////////////////////////////////////

RMstatus RMWmvHDParser::GetMetadata(guiWmvHDMetadataType *metadata)
{
	RMMemcpy(metadata, &m_metadata, sizeof(m_metadata));
	return RM_OK;	
}


RMstatus RMWmvHDParser::SetMetadataValue(TiXmlElement *pnode, RMascii *nodename)
{
	const RMascii *str;
	TiXmlNode *ptempNode;

	ptempNode = pnode->FirstChild();
	if(ptempNode == NULL)
		return RM_ERROR;
	
	str = ptempNode->Value();
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read metadata value... error\n"));
		return RM_ERROR;
	}
	
	if(RMCompareAsciiCaseInsensitively (nodename, (RMascii *)XMLSUPPORTTEXT_NODE)) {
		m_metadata.supportText = STRDUP(str);
	}
	else if(RMCompareAsciiCaseInsensitively (nodename, (RMascii *)XMLCONTENTDISTRIBUTOR_NODE)) {
		m_metadata.contentDistributor = STRDUP(str);
	}
	else if(RMCompareAsciiCaseInsensitively (nodename, (RMascii *)XMLCOPYRIGHT_NODE)) {
		m_metadata.copyright = STRDUP(str);
	}
	else if(RMCompareAsciiCaseInsensitively (nodename, (RMascii *)XMLTITLE_NODE)) {
		m_metadata.title = STRDUP(str);
	}
	else if(RMCompareAsciiCaseInsensitively (nodename, (RMascii *)XMLGENRE_NODE)) {
		m_metadata.genre = STRDUP(str);
	}
	else if(RMCompareAsciiCaseInsensitively (nodename, (RMascii *)XMLDIRECTOR_NODE)) {
		m_metadata.director = STRDUP(str);
	}
	else
		return RM_ERROR;
		
	return RM_OK;
}


void RMWmvHDParser::FreeMetadata()
{
	if(m_metadata.supportText != (RMascii *)NULL){
		RFREE(m_metadata.supportText);
		m_metadata.supportText = NULL;
	}
	if(m_metadata.contentDistributor != (RMascii *)NULL){
		RFREE(m_metadata.contentDistributor);
		m_metadata.contentDistributor = NULL;
	}
	if(m_metadata.copyright != (RMascii *)NULL){
		RFREE(m_metadata.copyright);
		m_metadata.copyright = NULL;
	}
	if(m_metadata.title != (RMascii *)NULL){
		RFREE(m_metadata.title);
		m_metadata.title = NULL;
	}
	if(m_metadata.genre != (RMascii *)NULL){
		RFREE(m_metadata.genre);
		m_metadata.genre = NULL;
	}
	if(m_metadata.director != (RMascii *)NULL){
		RFREE(m_metadata.director);
		m_metadata.director = NULL;
	}
}



////////////////////////////////////////////////////////////////////////////////
// PAGE -- MENU OBJECT
////////////////////////////////////////////////////////////////////////////////

guiOsdPageType* RMWmvHDParser::ParseOsdPage(TiXmlElement *pnode)
{
	const RMascii *str;
	guiOsdPageType* page;
	TiXmlElement *ptempNode;
	RMuint8 index = 0;
	RMuint8 zIndex = 0;
		
	page =(guiOsdPageType*)CALLOC(1, sizeof(guiOsdPageType));
	
	str = pnode->Attribute(XMLID_NODE, true);
	if (str == (RMascii *)NULL) {
		RMDBGLOG((GUIPARSERDBG, "Could not read id (ParseOsdPage) ... error\n"));
		goto invalidPage;
	}
	else {
		page->name = STRDUP(str);
	}
	
	// set visibility -- not defined in WMHD xml
	page->object.visible = TRUE;
	
	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, XMLIMAGE_NODE)) {
			page->bitmaps[page->nbBitmaps] = ParseBitmap(ptempNode);
			if(page->bitmaps[page->nbBitmaps] != (guiBitmapType*)NULL){
				page->nbBitmaps++;
			}			
		}
		else if (RMCompareAsciiCaseInsensitively (str, XMLBUTTON_NODE)) {
			page->buttons[page->nbButtons] = ParseButton(ptempNode);
			if(page->buttons[page->nbButtons] != (guiButtonType*)NULL){
				page->nbButtons++;
			}			
		}
		else {
			RMDBGLOG((GUIPARSERDBG, "unknown node [%s] in menuobject\n", str));
		}
	}
		
	// find path
	for(RMuint8 i = 0; i < page->nbBitmaps; i++){
		if(i == 0)
			zIndex = page->bitmaps[i]->object.zIndex;
		if(page->bitmaps[i]->object.zIndex <= zIndex)
			index = i;
	}
	RMASSERT(page->nbBitmaps);
	
	if(page->nbBitmaps == 0)
		goto invalidPage;
	
	page->object.file = STRDUP(page->bitmaps[index]->object.file);
	// mark bitmap as non-visible not to draw it twice
	page->bitmaps[index]->object.visible = FALSE;
	
	// set default button as the first in the list
	if(page->nbButtons){
		page->selectedObject = STRDUP(page->buttons[0]->name);
		page->buttons[0]->object.state = STATE_SELECTED;
	}
		
	// set ids
	page->id = m_nbOsdPages + PAGE_START_ID;

	RMDBGLOG((GUIPARSERDBG, "end page\n"));
	return page;

 invalidPage:
	FreeOsdPage(page);
	return (guiOsdPageType*)NULL;
}


void RMWmvHDParser::FreeOsdPage(guiOsdPageType *page)
{
	RMuint16 i;
	
	if(page == NULL)
		return;
		
	if(page->name != (RMascii *)NULL){
		RFREE(page->name);
		page->name = NULL;
	}		
	
	if(page->selectedObject != (RMascii *)NULL){
		RFREE(page->selectedObject);
		page->selectedObject = NULL;
	}		
	
	if(page->object.file != (RMascii *)NULL){
		RFREE(page->object.file);
		page->object.file = NULL;
	}
	
	for(i=0; i < page->nbButtons; i++){
		FreeButton(page->buttons[i]);
		page->buttons[i] = NULL;
	}
	for(i=0; i < page->nbBitmaps; i++){
		FreeBitmap(page->bitmaps[i]);
		page->bitmaps[i] = NULL;
	}
	RFREE(page);
}


RMstatus RMWmvHDParser::GetPages(guiOsdPageType *pages[MAX_GUI_PAGES], RMuint16 *nPages)
{
	if(m_nbOsdPages){
		RMMemcpy(pages, m_osdPages, sizeof(m_osdPages));
		*nPages = m_nbOsdPages;
		return RM_OK;
	}
	return RM_ERROR;
}


////////////////////////////////////////////////////////////////////////////////
// EVENTS
////////////////////////////////////////////////////////////////////////////////

// These are allocated while the parent object is parsed