fakegui.cpp

sigmadesign smp8623 gui source code ,bingo

/*****************************************
 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
#endif

RMcuracaoGui::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;
}