/***************************************** Copyright  2001-2003   Sigma Designs, Inc. All Rights Reserved Proprietary and Confidential *****************************************//**  @file   fakegui.cpp  @brief  file to link with when you don't want any gui    @author Laurent Crinon  @date   2004-05-12*/#ifndef ALLOW_OS_CODE#define ALLOW_OS_CODE 1#endif //ALLOW_OS_CODE#include "../common.h"#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "gui.h"#if 1#define FAKEGUIDBG ENABLE#else#define FAKEGUIDBG DISABLE#endif#if 0#define FAKEGUINTFYDBG ENABLE#else#define FAKEGUINTFYDBG DISABLE#endifRMcuracaoGui::RMcuracaoGui(typeCuracaoContext *context)	: m_context (context){	RMDBGLOG((FAKEGUIDBG, "NO GUI AVAILABLE ...\n"));	m_crc_table_computed = FALSE;}RMcuracaoGui::~RMcuracaoGui(){}RMstatus RMcuracaoGui::Initialize(RMnonAscii *xmlFile){	RMMemset(&m_settings, 0, sizeof(guiPlayerSettingsType));	RMMemset(&m_loadsettings, 0, sizeof(guiPlayerSettingsType));	RetrievePlayerSettings();	return RM_OK;}RMstatus RMcuracaoGui::SendKey(RMremoteKey c){	return InterpretCommand(c);}RMstatus RMcuracaoGui::SendEvent(RMguiEvent event){	return RM_ERROR;}RMascii* RMcuracaoGui::GetFile(){	return (RMascii*)NULL;}RMstatus RMcuracaoGui::Close(){	SavePlayerSettings();	return RM_OK;}RMstatus RMcuracaoGui::Notify(typeCuracaoMessage message, void *val){	RMstatus status;	switch (message) {	case CURACAO_MESSAGE_INVALID_OP:		RMDBGLOG((ENABLE, "*** Invalid UOP ***\n"));		break;	case CURACAO_MESSAGE_PLAY_MODE:{		typePlayMode *playMode = (typePlayMode *)val;		switch(playMode->state){		case STATE_PLAY:			switch(m_context->discType){			case RM_DISC_TYPE_ISO9660:				break;			case RM_DISC_TYPE_CDDA:				break;			default:				break;			}								break;		case STATE_STOP:			RMDBGLOG((FAKEGUINTFYDBG, "** Received STOP MODE **\n"));						break;		case STATE_PAUSE:			RMDBGLOG((FAKEGUINTFYDBG, "** Received PAUSE MODE **\n"));						break;		case STATE_STEP:			RMDBGLOG((FAKEGUINTFYDBG, "** Received STEP MODE **\n"));						break;		case STATE_CLOSE:						RMDBGLOG((FAKEGUINTFYDBG, "** Received CLOSE MODE **\n"));			break;						case STATE_FAST_FORWARD:						break;					case STATE_FAST_REWIND:						break;		case STATE_SLOW_FORWARD:						break;		default:			return RM_ERROR;					}				m_playMode = playMode->state;	}		break;				case CURACAO_MESSAGE_UNSUPPORTED_MEDIA:		RMDBGLOG((FAKEGUINTFYDBG,"** Unsupported media **\n"));		break;	case CURACAO_MESSAGE_DVD_WRONG_REGION:		RMDBGLOG((FAKEGUINTFYDBG,"** Wrong DVD region **\n"));		break;	case CURACAO_MESSAGE_MEDIA_INFO:		if(m_context->discType == RM_DISC_TYPE_CDDA){			RMMemcpy(&m_cddaInfo, (typeCuracaoCddaInfo *)val, sizeof(typeCuracaoCddaInfo));			RMDBGLOG((ENABLE, 				  "** Track %hu/%hu, %lu/%lu secs, total %lu secs **\n",				  m_cddaInfo.nCurrentTrack,				  m_cddaInfo.nTracks,				  m_cddaInfo.trackTime,				  m_cddaInfo.currentTrackDuration,				  m_cddaInfo.totalDuration));		}		else if(m_context->discType == RM_DISC_TYPE_VCD || m_context->discType == RM_DISC_TYPE_SVCD){			RMMemcpy(&m_vcdInfo, (typeCuracaoVcdInfo *)val, sizeof(typeCuracaoVcdInfo));		}		else if(m_context->discType == RM_DISC_TYPE_DVD_VIDEO){			RMMemcpy(&m_dvdInfo, (typeCuracaoDvdInfo *)val, sizeof(typeCuracaoDvdInfo));			RMDBGLOG((FAKEGUINTFYDBG,				  "** ChapterTime : %lu secs **\n",				  m_dvdInfo.chapterTime));		}		break;	case CURACAO_MESSAGE_DVD_SUBTITLE_CHANGE:{		typeCuracaoDvdSubpicStreamAttr *attr = (typeCuracaoDvdSubpicStreamAttr *)val;		if(attr->subpicStreamNumber == 0)			RMDBGLOG((ENABLE, "** Subpicture : Off **\n"));		else {			if(attr->subpicStreamAttr.isLanguage)				RMDBGLOG((ENABLE,"** Subpicture : %c%c **\n", (RMascii)(HIBYTE(attr->subpicStreamAttr.languageCode) - 32), (RMascii)LOBYTE(attr->subpicStreamAttr.languageCode) - 32));			else				RMDBGLOG((ENABLE, "** Subpicture : stream #%d **\n", attr->subpicStreamNumber));		} 	}		break;		case CURACAO_MESSAGE_DVD_AUDIOSTREAM_CHANGE:{		typeCuracaoDvdAudioStreamAttr *attr = (typeCuracaoDvdAudioStreamAttr *)val;		if(attr->audioStreamAttr.isLanguage)			RMDBGLOG((ENABLE,"** Audio : %c%c **\n", (RMascii)(HIBYTE(attr->audioStreamAttr.languageCode) - 32), (RMascii)LOBYTE(attr->audioStreamAttr.languageCode) - 32));		else			RMDBGLOG((ENABLE,"** Audio : stream #%d **\n", attr->audioStreamNumber));	}		break;		case CURACAO_MESSAGE_DVD_ANGLE_CHANGE:		RMDBGLOG((ENABLE, "** Angle : #%d **\n", (RMascii)(*(RMuint8 *)val)));	 		break;			case CURACAO_MESSAGE_DVD_REPEAT_CHAPTER:		RMDBGLOG((ENABLE,"** Repeat Chapter is On **\n"));		break;	case CURACAO_MESSAGE_DVD_REPEAT_TITLE:		RMDBGLOG((ENABLE,"** Repeat Title is On **\n"));		break;	case CURACAO_MESSAGE_DVD_REPEAT_OFF:		RMDBGLOG((ENABLE,"** Repeat is Off **\n"));		break;	case CURACAO_MESSAGE_DVD_REPEAT_A_SET:		RMDBGLOG((ENABLE,"** Repeat A->B : A point is set **\n"));		break;	case CURACAO_MESSAGE_DVD_REPEAT_B_SET:		RMDBGLOG((ENABLE,"** Repeat A->B : B point is set **\n"));		break;	case CURACAO_MESSAGE_DVD_REPEAT_AB_CLEARED:		RMDBGLOG((ENABLE,"** Repeat A->B : Cleared **\n"));		break;	case CURACAO_MESSAGE_DVD_STOPPED:		RMDBGLOG((ENABLE,"** Saving bookmark **\n"));		m_settings.bookmarkCRC = 0;		status = m_context->player->GetBookmark(m_settings.bookmark, BOOKMARK_SIZE);		if(RMSUCCEEDED(status) && m_context->player)			m_settings.bookmarkCRC = m_context->player->GetDiscID();		m_settings.validBookmark = (m_settings.bookmarkCRC != 0);		break;			case CURACAO_MESSAGE_PLAYBACK_STARTED:{		RMDBGLOG((ENABLE,"** Retrieving bookmark **\n"));		RMuint32 discId = *((RMuint32*)val);		if(m_settings.validBookmark && discId != 0){			if(discId == m_settings.bookmarkCRC){				m_resumeOn = TRUE;			}		}			}		break;			case CURACAO_MESSAGE_DVD_MENU_STATE: {		RMbool menuOn = *((RMbool*)val);			if(menuOn) RMDBGLOG((FAKEGUINTFYDBG,"** Now navigating a Menu **\n"));	}		break;	default://		printf("message not implemented yet\n");		break;	}	return RM_ERROR;}RMstatus RMcuracaoGui::DiscState(){	return RM_ERROR;}RMstatus RMcuracaoGui::GetDvdParameters(typeCuracaoDvdParameters *params){	return RM_ERROR;}// this is the main interpreter for remote control commands// it interprets all dvd player specific commands (display, sound, on/off, ...)RMstatus RMcuracaoGui::InterpretCommand(RMremoteKey c){	RMstatus status = RM_ERROR;		switch(c){	case RM_HW_EJECT: // open/close command		if(m_context->disc != 0){			RMbool isOpen;						if(m_context->player != 0){				RMDBGLOG((FAKEGUIDBG, "Closing media player ...\n"));				m_context->player->Close();				RMDBGLOG((FAKEGUIDBG, "Deleting media player ...\n"));				delete (m_context->player);				m_context->player = 0;			}			status = RMFDiscIsTrayOpen (m_context->disc, &isOpen);			if (status != RM_OK) {				RMDBGLOG((FAKEGUIDBG, "Cannot determine whether drive is opened. Bad drive.\n"));				break;			} else {				if (isOpen) {					status = RMFDiscCloseTray (m_context->disc);					RMDBGLOG((FAKEGUIDBG, "Loading..."));					m_context->isDiscDetected = FALSE;				} else {					status = RMFDiscOpenTray (m_context->disc);					m_context->isDiscDetected = TRUE;					m_context->discType = RM_NO_DISC;									}			}							}		break;	case RM_HW_ON_OFF: // exit		RMDBGLOG((FAKEGUIDBG, "Exit ...\n"));		m_context->needToExit = TRUE; 		status = RM_OK;		break;	case RM_HW_OSD: 		break;	case RM_HW_VOL_PLUS:	case RM_HW_VOL_MINUS:	case RM_HW_MUTE:	case RM_HW_L_R:	case RM_HW_VGA_TV:		// to be implemented		status = RM_ERROR;		break;	case RM_HW_PLAY_PAUSE:		status = HandlePlay();		break;	case RM_HW_STOP:		m_resumeOn = TRUE;		status = RM_UNKNOWN_KEY;		break;			default:		RMDBGLOG((FAKEGUIDBG, "Unknown command for the main interpreter\n"));		status = RM_UNKNOWN_KEY;		break;	}	return status;}RMstatus RMcuracaoGui::HandlePlay(){	RMstatus status = RM_UNKNOWN_KEY;		// it tray open, close it and return	if(m_context->disc != 0){		RMbool isOpen;		if(RMFDiscIsTrayOpen (m_context->disc, &isOpen) == RM_OK) {			if(isOpen){				RMFDiscCloseTray (m_context->disc);				m_context->isDiscDetected = FALSE;				return status;			}		}	}		if(m_context->discType == RM_DISC_TYPE_DVD_VIDEO && m_resumeOn){		if(m_context->player){			m_settings.validBookmark = FALSE;			m_context->player->ResumeBookmark(m_settings.bookmark);			m_resumeOn = FALSE;		}		return status;	}		return status;}RMstatus RMcuracaoGui::GetParentalLevelClearance(RMuint8 discRating){	return RM_ERROR;}RMstatus RMcuracaoGui::SavePlayerSettings(){	int file;	ssize_t ret = -1;	RMstatus status = RM_OK;		if(RMMemcmp(&m_loadsettings, &m_settings, sizeof(m_settings)) != 0){		RMDBGLOG((FAKEGUIDBG, "Saving player settings, using %s file, size %d\n", SETTINGS_FILE, sizeof(m_settings)));		// PrintPlayerSettings(m_settings);				m_settings.crc = CalculateCRC((RMuint8*)&m_settings, sizeof(m_settings)/2);		RMDBGLOG((FAKEGUIDBG, "Calculated CRC = 0x%08X\n", m_settings.crc));			file = open(SETTINGS_FILE, O_RDWR | O_SYNC);		if(file != -1){			RMDBGLOG((FAKEGUIDBG, "Writting ...\n"));			ret = write(file, &m_settings, sizeof(m_settings));			RMDBGLOG((FAKEGUIDBG, "Fsync ...\n"));			fsync(file);			RMDBGLOG((FAKEGUIDBG, "Close ...\n"));			close(file);			RMDBGLOG((FAKEGUIDBG, "Finish saving settings\n"));		}		status = (ret != -1 ? RM_OK : RM_ERROR);				if(RMFAILED(status)){			RMDBGLOG((FAKEGUIDBG, "Error saving player settings!!\n"));		}			else{			// not to save again...			RMMemcpy(&m_loadsettings, &m_settings, sizeof(m_settings));			RMDBGLOG((FAKEGUIDBG, "Saved player settings succeeded!!\n"));		}	}	return status;}RMstatus RMcuracaoGui::RetrievePlayerSettings(){	int file;	ssize_t ret = -1;	RMuint32 current_crc;	RMuint32 calculated_crc;				RMDBGLOG((FAKEGUIDBG, "Retrieving player settings, using %s file\n", SETTINGS_FILE));	// read settings if already saved	file = open(SETTINGS_FILE, O_RDONLY | O_SYNC);	if(file != -1){		RMDBGLOG((FAKEGUIDBG, "Reading previous settings, size %u...\n", sizeof(m_settings)));		ret = read(file, &m_settings, sizeof(m_settings));		if(ret != sizeof(m_settings))			RMDBGLOG((FAKEGUIDBG, "Error reading player settings\n"));		close(file);		current_crc = m_settings.crc;		m_settings.crc = 0;		calculated_crc = CalculateCRC((RMuint8*)&m_settings, sizeof(m_settings)/2);				if(current_crc != calculated_crc){			RMDBGLOG((FAKEGUIDBG, "CRC mismatch ... resetting settings: found = 0x%08X, calculated = 0x%08X\n", current_crc, calculated_crc));				// SetDefaultPlayerSettings();			m_settings.crc = calculated_crc;			// need to open it in write mode ...			file = open(SETTINGS_FILE, O_WRONLY | O_SYNC);			ret = write(file, &m_settings, sizeof(m_settings));			if(ret != sizeof(m_settings))				RMDBGLOG((FAKEGUIDBG, "Error writting player settings\n"));			fsync(file);			close(file);		}		else			RMDBGLOG((FAKEGUIDBG, "CRC match ... found = 0x%08X, calculated = 0x%08X\n", current_crc, calculated_crc));			}	else{		// load default settings		// SetDefaultPlayerSettings();				RMDBGLOG((FAKEGUIDBG, "No previous Settings, creating the settings file...\n"));		file = open(SETTINGS_FILE, O_WRONLY | O_SYNC | O_CREAT, S_IRUSR | S_IWUSR);		if(file != -1){			ret = write(file, &m_settings, sizeof(m_settings));			if(ret != sizeof(m_settings))				RMDBGLOG((FAKEGUIDBG, "Error writting player settings\n"));			fsync(file);			close(file);		}	}		// save to compare before saving	RMMemcpy(&m_loadsettings, &m_settings, sizeof(m_settings));		// ApplyPlayerSettings();		return RM_OK;}void RMcuracaoGui::make_crc_table(void){     RMuint32 c;     RMuint16 n, k;        for (n = 0; n < 256; n++) {	     c = (RMuint32) n;	     for (k = 0; k < 8; k++) {		     if (c & 1)			     c = 0xedb88320L ^ (c >> 1);		     else			     c = c >> 1;	     }	     m_crc_table[n] = c;     }     m_crc_table_computed = TRUE;}   RMuint32 RMcuracaoGui::update_crc(RMuint32 crc, RMuint8 *buf, RMuint32 len){     RMuint32 c = crc;     RMuint32 n;        if (!m_crc_table_computed)	     make_crc_table();     for (n = 0; n < len; n++) {	     c = m_crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);     }     return c;}   RMuint32 RMcuracaoGui::CalculateCRC(RMuint8 *buffer, RMuint32 size){	return update_crc(0xffffffffL, buffer, size) ^ 0xffffffffL;}