process_key.c

Sample code for use on smp 863x processor.

			(dist < 0) ? -(((-dist) / rounds) / (xtal_freq / 1000000)) : (dist / rounds) / (xtal_freq / 1000000));
		break;
	}
	case KEY_CMD_DISPLAY_INFO: {
		if (dcc_info->SurfaceID) {
			RMuint32 skip, dup;
			
			err = RUAGetProperty(dcc_info->pRUA, dcc_info->SurfaceID, RMGenericPropertyID_DisplaySkipCount, &skip, sizeof(skip));
			if (RMFAILED(err)) 
				fprintf(stderr, "Cannot get skip count\n");
			
			err = RUAGetProperty(dcc_info->pRUA, dcc_info->SurfaceID, RMGenericPropertyID_DisplayDuplicateCount, &dup, sizeof(dup));
			if (RMFAILED(err)) 
				fprintf(stderr, "Cannot get dup count\n");
			
			fprintf(stderr, "SKIP: %lu, DUP: %lu\n", skip, dup);
		}	
		else {
			fprintf(stderr, "No video scaler\n");
		}
		break;
	}
	case KEY_CMD_VSYNCTIMES: {
		struct DispDigitalOut_VSyncTimes_type VSyncTimes;
		static const RMascii PortName[6][4] = {"CVB", "YUV", "MAO", "DIG", "VID", "GFX"};
		#define VSYNCTIMES_THRESHOLD 2700000
		
		while ((err = RUASetProperty(dcc_info->pRUA, DispDigitalOut, RMDispDigitalOutPropertyID_UpdateVSyncTimes, NULL, 0, 0)) == RM_PENDING);
		while ((err = RUASetProperty(dcc_info->pRUA, DispDigitalOut, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
		while ((err = RUAGetProperty(dcc_info->pRUA, DispDigitalOut, RMDispDigitalOutPropertyID_VSyncTimes, &VSyncTimes, sizeof(VSyncTimes))) == RM_PENDING);
		if (RMFAILED(err)) {
			fprintf(stderr, "Error getting VSyncTimes!\n");
		} else {
			RMuint32 i, VSyncTime, FrameTime;
			RMint32 VSyncDelay, FrameDelay;
			
			fprintf(stderr, " -- Xtal values at VSync:\n");
			for (i = 0; i < 6; i++) {
				VSyncTime = RMCyclesElapsed32(VSyncTimes.VSyncTime[i][1], VSyncTimes.VSyncTime[i][0]);
				FrameTime = RMCyclesElapsed32(VSyncTimes.FrameTime[i][1], VSyncTimes.FrameTime[i][0]);
				//fprintf(stderr, "%s, VSync: 0x%08lX-0x%08lX=%lu %3lu.%03llu Hz, Frame: 0x%08lX-0x%08lX=%lu %3lu.%03llu Hz\n", PortName[i], 
				//	VSyncTimes.VSyncTime[i][1], VSyncTimes.VSyncTime[i][0], VSyncTime, VSyncTime ? (27000000 / VSyncTime) : 0, VSyncTime ? ((27000000000LL / VSyncTime) % 1000) : 0, 
				//	VSyncTimes.FrameTime[i][1], VSyncTimes.FrameTime[i][0], FrameTime, FrameTime ? (27000000 / FrameTime) : 0, FrameTime ? ((27000000000LL / FrameTime) % 1000) : 0);
				if ((VSyncTime || FrameTime) && (VSyncTime < VSYNCTIMES_THRESHOLD) && (FrameTime < VSYNCTIMES_THRESHOLD)) {
					fprintf(stderr, "%s, VSync: %3lu.%03llu Hz, %6lu uSec; Frame: %3lu.%03llu Hz, %6lu uSec\n", PortName[i], 
						VSyncTime ? (27000000 / VSyncTime) : 0, VSyncTime ? ((27000000000LL / VSyncTime) % 1000) : 0, VSyncTime / 27, 
						FrameTime ? (27000000 / FrameTime) : 0, FrameTime ? ((27000000000LL / FrameTime) % 1000) : 0, FrameTime / 27);
				}
			}
			
			VSyncDelay = RMCyclesElapsed32(VSyncTimes.VSyncTime[3][0], VSyncTimes.VSyncTime[2][0]);
			if (VSyncDelay < 0) VSyncDelay = -RMCyclesElapsed32(VSyncTimes.VSyncTime[2][0], VSyncTimes.VSyncTime[3][0]);
			FrameDelay = RMCyclesElapsed32(VSyncTimes.FrameTime[3][0], VSyncTimes.FrameTime[2][0]);
			if (FrameDelay < 0) FrameDelay = -RMCyclesElapsed32(VSyncTimes.FrameTime[2][0], VSyncTimes.FrameTime[3][0]);
			//fprintf(stderr, "%s to %s delay, VSync: %ld, %ld uSec, Frame: %ld, %ld uSec\n", 
			//	PortName[3], PortName[2], 
			//	VSyncDelay, VSyncDelay / 27, 
			//	FrameDelay, FrameDelay / 27);
			if ((VSyncDelay < VSYNCTIMES_THRESHOLD) && (VSyncDelay > -VSYNCTIMES_THRESHOLD) && (FrameDelay < VSYNCTIMES_THRESHOLD) && (FrameDelay > -VSYNCTIMES_THRESHOLD)) {
				fprintf(stderr, "%s to %s delay, VSync: %+6ld uSec, Frame: %+6ld uSec\n", 
					PortName[3], PortName[2], VSyncDelay / 27, FrameDelay / 27);
			}
			
			VSyncDelay = RMCyclesElapsed32(VSyncTimes.VSyncTime[3][0], VSyncTimes.VSyncTime[1][0]);
			if (VSyncDelay < 0) VSyncDelay = -RMCyclesElapsed32(VSyncTimes.VSyncTime[1][0], VSyncTimes.VSyncTime[3][0]);
			FrameDelay = RMCyclesElapsed32(VSyncTimes.FrameTime[3][0], VSyncTimes.FrameTime[1][0]);
			if (FrameDelay < 0) FrameDelay = -RMCyclesElapsed32(VSyncTimes.FrameTime[1][0], VSyncTimes.FrameTime[3][0]);
			if ((VSyncDelay < VSYNCTIMES_THRESHOLD) && (VSyncDelay > -VSYNCTIMES_THRESHOLD) && (FrameDelay < VSYNCTIMES_THRESHOLD) && (FrameDelay > -VSYNCTIMES_THRESHOLD)) {
				fprintf(stderr, "%s to %s delay, VSync: %+6ld uSec, Frame: %+6ld uSec\n", 
					PortName[3], PortName[1], VSyncDelay / 27, FrameDelay / 27);
			}
			
			VSyncDelay = RMCyclesElapsed32(VSyncTimes.VSyncTime[3][0], VSyncTimes.VSyncTime[4][0]);
			if (VSyncDelay < 0) VSyncDelay = -RMCyclesElapsed32(VSyncTimes.VSyncTime[4][0], VSyncTimes.VSyncTime[3][0]);
			FrameDelay = RMCyclesElapsed32(VSyncTimes.FrameTime[3][0], VSyncTimes.FrameTime[4][0]);
			if (FrameDelay < 0) FrameDelay = -RMCyclesElapsed32(VSyncTimes.FrameTime[4][0], VSyncTimes.FrameTime[3][0]);
			if ((VSyncDelay < VSYNCTIMES_THRESHOLD) && (VSyncDelay > -VSYNCTIMES_THRESHOLD) && (FrameDelay < VSYNCTIMES_THRESHOLD) && (FrameDelay > -VSYNCTIMES_THRESHOLD)) {
				fprintf(stderr, "%s to %s delay, VSync: %+6ld uSec, Frame: %+6ld uSec\n", 
					PortName[3], PortName[4], VSyncDelay / 27, FrameDelay / 27);
			}
			
			VSyncDelay = RMCyclesElapsed32(VSyncTimes.VSyncTime[3][0], VSyncTimes.VSyncTime[5][0]);
			if (VSyncDelay < 0) VSyncDelay = -RMCyclesElapsed32(VSyncTimes.VSyncTime[5][0], VSyncTimes.VSyncTime[3][0]);
			FrameDelay = RMCyclesElapsed32(VSyncTimes.FrameTime[3][0], VSyncTimes.FrameTime[5][0]);
			if (FrameDelay < 0) FrameDelay = -RMCyclesElapsed32(VSyncTimes.FrameTime[5][0], VSyncTimes.FrameTime[3][0]);
			if ((VSyncDelay < VSYNCTIMES_THRESHOLD) && (VSyncDelay > -VSYNCTIMES_THRESHOLD) && (FrameDelay < VSYNCTIMES_THRESHOLD) && (FrameDelay > -VSYNCTIMES_THRESHOLD)) {
				fprintf(stderr, "%s to %s delay, VSync: %+6ld uSec, Frame: %+6ld uSec\n", 
					PortName[3], PortName[5], VSyncDelay / 27, FrameDelay / 27);
			}
			
		}
		break;
	}
	case KEY_CMD_FILTER_SELECT: {
		struct DispMainVideoScaler_FilterSelection_type filtermode;
		RMuint32 i;
		
		RUAGetProperty(dcc_info->pRUA, DispMainVideoScaler, RMDispMainVideoScalerPropertyID_FilterSelection, &(filtermode), sizeof(filtermode));
		if (! filtermode.Boundary_2_3) {
			i = 4;
		} else if (! filtermode.Boundary_1_2) {
			i = 3;
		} else if (! filtermode.Boundary_0_1) {
			i = 2;
		} else if (filtermode.Boundary_0_1 < 0x2000) {
			i = 0;
		} else {
			i = 1;
		}
		i = (i + 1) % 5;
		switch (i) {
		case 0:
			fprintf(stderr, "Filter config: normal\n");
			filtermode.Boundary_0_1 = 0x1400;
			filtermode.Boundary_1_2 = 0x1c00;
			filtermode.Boundary_2_3 = 0x2c00;
			break;
		case 1:
			fprintf(stderr, "Filter config: always 0\n");
			filtermode.Boundary_0_1 = 0x4000;
			filtermode.Boundary_1_2 = 0x4000;
			filtermode.Boundary_2_3 = 0x4000;
			break;
		case 2:
			fprintf(stderr, "Filter config: always 1\n");
			filtermode.Boundary_0_1 = 0x0000;
			filtermode.Boundary_1_2 = 0x4000;
			filtermode.Boundary_2_3 = 0x4000;
			break;
		case 3:
			fprintf(stderr, "Filter config: always 2\n");
			filtermode.Boundary_0_1 = 0x0000;
			filtermode.Boundary_1_2 = 0x0000;
			filtermode.Boundary_2_3 = 0x4000;
			break;
		case 4:
			fprintf(stderr, "Filter config: always 3\n");
			filtermode.Boundary_0_1 = 0x0000;
			filtermode.Boundary_1_2 = 0x0000;
			filtermode.Boundary_2_3 = 0x0000;
			break;
		}
		while ((err = RUASetProperty(dcc_info->pRUA, DispMainVideoScaler, RMDispMainVideoScalerPropertyID_FilterSelection, &(filtermode), sizeof(filtermode), 0)) == RM_PENDING);
		while ((err = RUASetProperty(dcc_info->pRUA, DispMainVideoScaler, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
		break;
	}
	case KEY_CMD_HDCP_TOGGLE:
		if (dcc_info->dh_info && dcc_info->dh_info->pDH) {
			RMascii k;
			fprintf(stderr, "HDCP ");
			k = RMGetKey(); fprintf(stderr, "'%c':", k);
			switch (k) {
			case '0':
				fprintf(stderr, " Off\n");
				DHCancelHDCP(dcc_info->dh_info->pDH);
				break;
			case '1':
				fprintf(stderr, " On\n");
				DHRequestHDCP(dcc_info->dh_info->pDH);
				break;
			case '2':
				fprintf(stderr, " Silent On\n");
				DHRequestSilentHDCP(dcc_info->dh_info->pDH);
				break;
			default:
				fprintf(stderr, " ERROR: 0, 1 or 2\n");
			}
		}
		break;
	default:
		*processed = FALSE;
	}
	return RM_OK;
}

RMstatus handle_key(struct dcc_context *dcc_info, RMuint32 *cmd, RMuint32 keyflags, RMascii key)
{
	RMbool update_out_window, processed;
	RMstatus err;
	
	update_out_window = FALSE;
	processed = FALSE;
	*cmd = RM_UNKNOWN;
	
	if ((key == KEY_CMD_NONE1) || (key == KEY_CMD_NONE2)) {
		goto out_key;
	}
	
	if (keyflags & SET_KEY_DEBUG) {
		handle_debug_key(dcc_info, key, &processed);
		if (processed == TRUE)
			goto out_key;
	}
	
	if (keyflags & SET_KEY_PLAYBACK) {
		processed = TRUE;
		switch (key) {
		case KEY_CMD_MANU_YES:
			if (manutest == TRUE) {
				*cmd = RM_MANU_QUIT_OK;
				break;
			}

		case KEY_CMD_PAUSE:
			if ((dcc_info->state != RM_PAUSED) && (dcc_info->state != RM_PLAYING) && (dcc_info->state != RM_PLAYING_TRICKMODE)) {
				fprintf(stderr, "Enter Play state first...\n");
				break;
			}

			fprintf(stderr, "Pausing...\n");
			if (dcc_info->pDemuxTask) {
				err = DCCPauseDemuxTask(dcc_info->pDemuxTask);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error pausing demux source %d\n", err));
					return err;
				}
			}
			if (dcc_info->pVideoSource) {
				err = DCCPauseVideoSource(dcc_info->pVideoSource);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error pausing video source %d\n", err));
					return err;
				}
			}
			
			if (dcc_info->pAudioSource) {
				err = DCCPauseAudioSource(dcc_info->pAudioSource);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error pausing audio source %d\n", err));
					return err;
				}
			}

			if (dcc_info->pStcSource) {
				DCCSTCStop(dcc_info->pStcSource);
			}

			dcc_info->state = RM_PAUSED;
			dcc_info->trickmode_id = RM_NO_TRICKMODE;
			*cmd = RM_PAUSE;
			break;
		
		case KEY_CMD_PLAY:
			fprintf(stderr, "Running...\n");
			if (dcc_info->pVideoSource) {
				err = DCCPlayVideoSource(dcc_info->pVideoSource, DCCVideoPlayFwd);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error playing video source %d\n", err));
					return err;
 				}
			}

			if (dcc_info->pAudioSource) {
				err = DCCPlayAudioSource(dcc_info->pAudioSource);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error playing audio source %d\n", err));
					return err;
				}
			}
			
			if (dcc_info->pDemuxTask) {
				err = DCCPlayDemuxTask(dcc_info->pDemuxTask);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error playing demux source %d\n", err));
					return err;
				}
			}

			if (dcc_info->pStcSource) {
				DCCSTCSetSpeed(dcc_info->pStcSource, 1, 1);
				DCCSTCPlay(dcc_info->pStcSource);
			}

			dcc_info->state = RM_PLAYING;
			dcc_info->trickmode_id = RM_NO_TRICKMODE;
			*cmd = RM_PLAY;
			break;
			
		case KEY_CMD_NEXT_PICTURE:
			if ((dcc_info->state != RM_PAUSED) && (dcc_info->trickmode_id != RM_TRICKMODE_NEXT_PIC)){
				fprintf(stderr, "Enter Pause state first...\n");
				break;
			}

			fprintf(stderr, "Next Picture...\n");
			if (dcc_info->pVideoSource) {
				/* 
				   IMPORTANT NOTE: This call only affects the display, so the video decoder remains in the current
				   playback state, ie: playFwd, playIFrame, etc.
				*/
				err = DCCPlayVideoSource(dcc_info->pVideoSource, DCCVideoPlayNextFrame);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error playing (next frame) video source %d\n", err));
					return err;
				}
			}
			if (dcc_info->pAudioSource) {
				err = DCCStopAudioSource(dcc_info->pAudioSource);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error stopping audio source %d\n", err));
					return err;
				}
			}

			dcc_info->state = RM_PLAYING_TRICKMODE;
			dcc_info->trickmode_id = RM_TRICKMODE_NEXT_PIC;
			*cmd = RM_PLAY;
			break;

		case KEY_CMD_STOP_ZERO:
		case KEY_CMD_STOP:
			fprintf(stderr, "Stopping...\n");
			if (dcc_info->pDemuxTask) {
				err = DCCStopDemuxTask(dcc_info->pDemuxTask);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error stopping demux source %d\n", err));
					return err;
				}
			}
			if (dcc_info->pVideoSource) {
				err = DCCStopVideoSource(dcc_info->pVideoSource, DCCStopMode_LastFrame);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error stopping video source %d\n", err));
					return err;
				}
			}
			
			if (dcc_info->pAudioSource) {
				err = DCCStopAudioSource(dcc_info->pAudioSource);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Error stopping audio source %d\n", err));
					return err;
				}
			}