guicommands.cpp.svn-base

sigmadesign smp8623 gui source code ,bingo

		*pCommandId = SET_HDMI_720P59_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_720P59_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_1080i59:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_1080I59_COMMAND\n"));
		*pCommandId = SET_HDMI_1080I59_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_1080I59_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_1080p59:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_1080P59_COMMAND\n"));
		*pCommandId = SET_HDMI_1080P59_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_1080P59_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_640x480p60:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_640x480p60_COMMAND\n"));
		*pCommandId = SET_HDMI_640x480p60_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_640x480p60_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_480i60:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_480I60_COMMAND\n"));
		*pCommandId = SET_HDMI_480I60_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_480I60_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_480p60:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_480P60_COMMAND\n"));
		*pCommandId = SET_HDMI_480P60_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_480P60_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_720p60:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_720P60_COMMAND\n"));
		*pCommandId = SET_HDMI_720P60_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_720P60_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_1080i60:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_1080I60_COMMAND\n"));
		*pCommandId = SET_HDMI_1080I60_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_1080I60_COMMAND;
		break;
	case EMhwlibTVStandard_HDMI_1080p60:
		RMDBGLOG((GUIDBG, "Commmand ID: SET_HDMI_1080P60_COMMAND\n"));
		*pCommandId = SET_HDMI_1080P60_COMMAND;
		*pHDDVIHdmiOut = SET_HDMI_1080P60_COMMAND;
		break;
	default:
		RMDBGLOG((GUIDBG, "Commmand ID: UNKNOWN\n"));
		*pCommandId = SET_TV_NTSC_CSVIDEO_COMMAND;
		*pCompositeOut = SET_TV_NTSC_CSVIDEO_COMMAND;
		return RM_ERROR;
	}
	return RM_OK;
}

RMstatus RMcuracaoGui::SetTVOut(RMuint32 commandId)
{
	RMuint32 standard;
	enum DCCVideoConnector connector;
	enum EMhwlibColorSpace color_space;
	RMstatus status;

	if (m_context->decoder == 0)
		return RM_ERROR;

	status = GetTvFormatFromCommand(commandId, &standard, &connector, &color_space);
	if (RMFAILED(status))
	{ // If fails, fall back on SD
		commandId = m_settings.tvOut;
		status = GetTvFormatFromCommand(commandId, &standard, &connector, &color_space);
	}
	if (commandId == SET_HDMI_AUTO_ON_COMMAND)
	{
		status = m_context->decoder->SetDVIHDMIAutoEDID(TRUE);
		m_settings.forceNoHDMI = FALSE;
		m_pnav->SetMenuItemText(SET_HDMI_AUTO_ON_COMMAND);
#ifdef GUI_REFID_3
		if(m_settings.tvStandard == TV_NTSC_COMMAND)
		m_pnav->UpdateMenuLink("TvModeMenuItem", "HDMINtscVideoModePopup");
		else
		m_pnav->UpdateMenuLink("TvModeMenuItem", "HDMIPalVideoModePopup");

		// Update TV Mode to "Auto"
		m_pnav->SetMenuItemTextByName("TvModeMenuItem", "Auto");
		m_pnav->UpdateMenuState("TvModeMenuItem", TRUE, FALSE);
		status = RM_OK;
#endif
	}
	else
	{
#ifdef GUI_REFID_2
		RMbool TvModeEnabled = TRUE;

		//Check for output connection change
		RMascii menuName[MAX_GUI_TEXT_VALUE];
		fprintf(stderr,"Checking connector. Active connector: %ld\n", m_settings.activeVideoOutput);

		switch(m_settings.activeVideoOutput)
		{

			case SET_NTSCSD_MODE_COMMAND:
			case SET_PALSD_MODE_COMMAND:
			RMCopyAscii(menuName, "SDVideoModePopup");
			TvModeEnabled = FALSE;
			break;
			case SET_HDCOMPONENT60_MODE_COMMAND:
			RMCopyAscii(menuName, "ComponentNtscVideoModePopup");
			break;
			case SET_HDCOMPONENT50_MODE_COMMAND:
			RMCopyAscii(menuName, "ComponentPalVideoModePopup");
			break;
			case SET_NTSCSCARTRGB_MODE_COMMAND:
			case SET_PALSCARTRGB_MODE_COMMAND:
			RMCopyAscii(menuName, "SCARTVideoModePopup");
			TvModeEnabled = FALSE;
			break;
			case SET_HDMI59_MODE_COMMAND:
			RMCopyAscii(menuName, "HDMINtscVideoModePopup");
			break;
			case SET_HDMI50_MODE_COMMAND:
			RMCopyAscii(menuName, "HDMIPalVideoModePopup");
			break;
			case SET_HDDVI60_MODE_COMMAND:
			RMCopyAscii(menuName, "DVINtscVideoModePopup");
			break;
			case SET_HDDVI50_MODE_COMMAND:
			RMCopyAscii(menuName, "DVIPalVideoModePopup");
			break;
			default:
			RMCopyAscii(menuName, "");
			fprintf(stderr,"****ERROR****  Active connector not found.\n");
			break;
		}

		if(!RMCompareAscii(menuName, ""))
		{
			m_pnav->UpdateMenuLink("TvModeMenuItem", menuName);
		}

		if(!TvModeEnabled)m_pnav->SetMenuItemText(SET_TV_NTSC_CSVIDEO_COMMAND); //Display Default SD text
		m_pnav->UpdateMenuState("TvModeMenuItem", TvModeEnabled, FALSE);

		// if on hdmi and auto is disabled, default to lowest hdmi resolutions
		if(commandId == SET_HDMI_AUTO_OFF_COMMAND)
		{
			// set auto HDMI to disabled since user made manual selection
			m_settings.hdDVIHdmi = SET_HDMI_AUTO_OFF_COMMAND;
			m_pnav->SetMenuItemText(SET_HDMI_AUTO_OFF_COMMAND);
			m_settings.forceNoHDMI = TRUE;

			if(m_settings.activeVideoOutput == SET_HDMI59_MODE_COMMAND)
			commandId = SET_HDMI_480P59_COMMAND;
			else if(m_settings.activeVideoOutput == SET_HDMI50_MODE_COMMAND)
			commandId = SET_HDMI_576P50_COMMAND;
			if(commandId != SET_HDMI_AUTO_OFF_COMMAND)
			GetTvFormatFromCommand(commandId, &standard, &connector, &color_space);
			else
			{
				m_context->decoder->SetDVIHDMIAutoEDID(FALSE); // do not use auto EDID
				AdjustVideoOutSettings();
				return RM_ERROR; // no actual change
			}
		}
#endif
		RMDBGLOG((ENABLE, "************ Setting Player preferred output to standard = %s, connector = %s and color_space = %s\n",
						StandardStr(standard), ConnectorStr(connector), ColorSpaceStr(color_space)));
		// why print it twice?
		//		fprintf(stderr, "************ Setting Player preferred output to standard = %s, connector = %s and color_space = %s\n",
		//			  StandardStr(standard), ConnectorStr(connector), ColorSpaceStr(color_space));
#ifndef GUI_REFID_3
		m_settings.forceNoHDMI = TRUE;
		//		m_settings.hdDVIHdmi = SET_HDMI_AUTO_OFF_COMMAND;
#endif
		m_context->decoder->SetDVIHDMIAutoEDID(FALSE); // do not use auto EDID
		status = m_context->decoder->SetTVOut(standard, connector, color_space, TRUE);
	}
	if (RMSUCCEEDED(status))
	{
		m_videoOut = commandId;
		AdjustVideoOutSettings();
		if (m_protectType == RMCssProtect)
		{
			m_context->decoder->UpdateOutputProtection(RMCssProtect, 1);
			HandleCSSProtection(); // may or may not kick in
		}
	}
	return status;
}

RMstatus RMcuracaoGui::ConfirmResolutionChange(RMuint32 popupId, RMuint32 previousMode, RMuint32 prevStandard)
{
	RMstatus status = RM_ERROR;

	if (ISPOPUP(popupId))
	{
		status = ShowPopup(popupId, TRUE);
		if (RMFAILED(status))
			return status;
	}

	RMremoteKey c = RM_HW_TIMEOUT;
	SetTimer(TIMER_VIDEOOUTCHANGE);
	m_previousVideoOut = previousMode;
	m_previousTVStandard = prevStandard;
	while (g_timer[TIMER_VIDEOOUTCHANGE])
	{
		c = RMFremoteWaitSymbol(m_context->rh, m_context->remoteTimeout);

		if (c > 0)
		{
			if (m_context->needToExit)
				return RM_ERROR;

			if (c == RM_HW_SELECT)
			{
				KillTimer(TIMER_VIDEOOUTCHANGE);
				break;
			}
			else if (c == RM_HW_LEFT || c == RM_HW_RIGHT)
			{
				SetTimer(TIMER_VIDEOOUTCHANGE);
				SendKey(c);
			}
		}

	}
	if (c == RM_HW_SELECT)
	{
		status = HandleActivation();
	}

	return status;
}

// this command sets region
RMstatus RMcuracaoGui::SetDvdRegion(typeCommandInfo *command)
{
	m_settings.dvdRegion = command->id - SET_REGION_0_COMMAND;
	if (command->validLink)
		m_pnav->ShowObjectValue(command->linkId);
	return RM_OK;
}

RMstatus RMcuracaoGui::SetMacrovision(typeCommandInfo *command)
{
	if (command->id == SET_MACROVISION_ON_COMMAND)
	{
		m_settings.macrovisionOn = TRUE;
	}
	else if (command->id == SET_MACROVISION_OFF_COMMAND)
	{
		m_settings.macrovisionOn = FALSE;
	}
	else
		return RM_ERROR;

	if (command->validLink == TRUE)
	{
		m_pnav->ShowObjectValue(command->linkId);
	}

	return RM_OK;
}

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

RMstatus RMcuracaoGui::PlayAVFile(RMascii* path)
{
	RMstatus status = RM_ERROR;

	// send it to file player
	if (m_context->player != 0)
	{
		RMDBGLOG((ENABLE,">>>>about to open %s\n", path));
		//		if(m_isoPlayList.active)
		//			m_pnav->DisplayEvent(PLAY_EVENT, TRUE, TIMER_NONE, m_eventText, PLAY_STR, DISPLAY_TEXT_ON_EVENT_ARG, 8, 180, 40);
		status = m_context->player->Open(path);
		if (RMFAILED(status))
		{
			RMDBGLOG((ENABLE,">>>>open %s failed\n", path));
			if (m_MediaList.active)
				return PlayNextMediaFile();
			else if (m_isoPlayList.active)
			{
				return PlayNextFile();
			}
		}
	}
	return status;
}

RMstatus RMcuracaoGui::StopAVFile()
{
	RMstatus status = RM_ERROR;

	// send close to file player
	if (m_context->player != 0)
	{
		status = m_context->player->Close();
	}
	return status;
}

// Play through gfx
RMstatus RMcuracaoGui::PlayPicture(RMascii* path)
{
	RMstatus status = RM_ERROR;

	RMDBGLOG((GUIDBG,"PlayPicture(): %s\n", path));
	if (!m_drawingPicture)
	{
		RMuint32 delay = (m_pnav->WMVHDOn() ? 0 : LOADINGFILE_DELAY);
		m_drawingPicture = TRUE;
		status = m_pnav->DisplayPicture(path, SCALE_FULLSCREEN, delay);
		m_drawingPicture = FALSE;
		m_playMode = STATE_PLAY;
		m_scrollOn = FALSE;
	}
	else
		return PlayPicture(path);

	if (m_pnav->WMVHDOn())
		return status;

	if (RMSUCCEEDED(status))
	{
		if (m_isoPlayList.usetimeout == TRUE)
			SetTimer(TIMER_SLIDESHOW);
	}
	else
	{
		HandleEvent(LOAD_PICTURE_ERROR_EVENT);
	}
	SetfipPlayMode();
	return RM_OK;
}

RMstatus RMcuracaoGui::PlaySelectedFile(RMuint16 isoitem)
{
	RMint32 next = -1; // play list index of given item
	typeIsoPath path;
	RMstatus status;

	// find index
	for (RMuint32 i = 0; i < m_isoPlayList.numItems; i++)
	{
		if (isoitem == m_isoPlayList.isoDataIndex[i])
		{
			next = i;
			break;
		}
	}

	if (next == -1)
		return RM_ERROR;

	m_isoPlayList.numCurrentItem = next;

	HandleEvent(LOADINGFILE_EVENT);

	// user may have stopped playback right away
	if (m_isoPlayList.active == FALSE)
		return RM_OK;

	if (RMFAILED(m_pnav->GetFilePath(m_isoPlayList.isoDataIndex[next], path, sizeof(typeIsoPath))))
		return RM_ERROR;

	RMguiFileType prevFileType = m_isoPlayList.filetype;
	m_isoPlayList.filetype = m_pnav->GetFileType(path);
	if (m_isoPlayList.filetype == FILETYPE_PICTURE)
	{
		status = PlayPicture(path);
	}
	else
	{
		m_isoPlayList.previous = FALSE;
		if (m_isoPlayList.repeat == REPEAT_TRACK)
			HandleRepeat(FALSE);
		if (prevFileType != FILETYPE_PICTURE)
			StopAVFile();
		status = PlayAVFile(path);
#ifndef WITH_MONO
		if(RMSUCCEEDED(status))
		{
			status = m_context->player->InterpretCommand(RM_HW_PLAY_PAUSE, NULL);
		}
#endif
	}

	return status;
}

RMstatus RMcuracaoGui::PlayFiles(RMascii* path, RMuint16 item)
{
	if (!m_bTV)
	{
		//	RMuint32 isoitem;
		RMuint32 count = 0;
		RMuint32 index = 0; // play list index of given item
		//	typeIsoListData isoList;
		RMuint32 numItems;
		RMstatus status = RM_ERROR;

		//	m_isoPlayList.active = TRUE;
		//	m_isoPlayList.starting = TRUE;
		//	m_isoPlayList.playSingle = TRUE;
		//	m_isoPlayList.filetype = m_pnav->GetFileType(path);
		//	m_isoPlayList.starting = FALSE;
		//	m_drawingPicture = FALSE;
		//	m_pnav->ShowOsd(FALSE);

		//	return PlayAVFile(path);

		//	if(RMFAILED(m_pnav->GetIsoList(&isoList)))
		//		return RM_ERROR;
		m_isoPlayList.isoDataIndex = NULL;
		//	m_isoPlayList.shuffled = NULL;


		ClearIsoPlayList();
		numItems = m_pnav->m_List.numItems;//isoList.hasGoUp ? isoList.numItems - 1 : isoList.numItems;

		if (numItems == 0)
			return RM_ERROR;

		// create list if not already present
		if (m_isoPlayList.isoPath == NULL)
		{
			m_isoPlayList.isoPath = (RMascii**) CALLOC(numItems, sizeof(RMascii*));
			if (m_isoPlayList.isoPath == NULL)
				return RM_ERROR;
			m_isoPlayList.shuffled = (RMuint32*) CALLOC(numItems, sizeof(RMuint32));

			RMMemset(m_isoPlayList.isoPath, 0, numItems * sizeof(RMascii*));
			//	m_isoPlayList.isoPathShuffled = (RMascii**)CALLOC(numItems, sizeof(RMascii*));
			//	if(m_isoPlayList.isoPathShuffled == NULL)
			//		m_shuffleOn = FALSE;
			if (m_isoPlayList.shuffled == NULL)
				m_shuffleOn = FALSE;
		}

		RMuint16 listIndex;
		m_pnav->GetObjectIndex(m_pnav->m_selectedObjectId, &listIndex);

		if ((RMguiFileType) m_pnav->m_osdPages[m_pnav->m_activePageId]->lists[listIndex]->object.filetype == FILETYPE_VIDEO)
		{
			RMascii* where;

			HTTPFile* f;
			where = RMCatAscii(m_pnav->m_parser->GetUrl(),
					m_pnav->m_osdPages[m_pnav->m_activePageId]->lists[listIndex]->items[item]->object.path, NULL);

			f = fetchOpen(where, RM_HTTP_VERBOSE);
			if (f)
			{
				RMuint8 buffer[256];
				if (buffer)
				{
					RMint16 n = fetchRead(buffer, 256, f);
					buffer[n] = '\0';
					//printf("%s\n", (RMascii*) buffer);
					//										guiListType* list = m_osdPages[m_pnav