process_key.c

1. 8623L平台

			case 'b': mod = &VM.HActive; break;
			case 'c': mod = &VM.HFrontPorch; break;
			case 'd': mod = &VM.HSyncWidth; break;
			case 'e': mod = &VM.HBackPorch; break;
			case 'f': VM.HSyncPolarity = ! VM.HSyncPolarity; break;
			case 'g': mod = &VM.VActive; break;
			case 'h': mod = &VM.VFrontPorch; break;
			case 'i': mod = &VM.VSyncWidth; break;
			case 'j': mod = &VM.VBackPorch; break;
			case 'k': VM.VSyncPolarity = ! VM.VSyncPolarity; break;
			case 'l': {
				VM.Interlaced = ! VM.Interlaced; 
				if (VM.Interlaced) {
					VM.VActive /= 2;
					VM.VFrontPorch /= 2;
					VM.VSyncWidth /= 2;
					VM.VBackPorch /= 2;
				} else {
					VM.VActive *= 2;
					VM.VFrontPorch *= 2;
					VM.VSyncWidth *= 2;
					VM.VBackPorch *= 2;
				}
				break;
			}
			}
			if (mod) {
				RMuint32 new = 0;
				RMbool parse = FALSE;
				fprintf(stderr, "press '+' or '-', or enter new value, <enter> to end\n");
				do {
					if (! parse) fprintf(stderr, "(%lu) ", *mod);
					k = RMGetKey();
							
					switch (k) {
					case '+': parse = FALSE; (*mod)++; break;
					case '-': parse = FALSE; if (*mod) (*mod)--; break;
					case '0': case '1': case '2': case '3': case '4': 
					case '5': case '6': case '7': case '8': case '9': 
						if (! parse) {
							new = 0;
							parse = TRUE;
						}
						fprintf(stderr, "%c", k);
						new = (new * 10) + (k - '0');
						break;
					case '\b': case '\177':
						if (parse) {
							fprintf(stderr, "%c", k);
							new /= 10;
						}
						break;
					case '\n': 
						if (parse) {
							*mod = new; 
							parse = FALSE; 
							k = ' ';
						}
						break;
					default: parse = FALSE; break;
					}
					if (!parse) {
						fprintf(stderr, "\n");
						err = set_modifyed_video_mode(dcc_info, &VM);
					}
				} while (k != '\n');
			} else {
				err = set_modifyed_video_mode(dcc_info, &VM);
			}
			if (RMFAILED(err)) {
				fprintf(stderr, "Error setting new mode!\n");
			}
		} while (TRUE);
		break;
	}
	case KEY_CMD_HIGHLIGHT:
		send_hilight_button(dcc_info);	
		break;
	case KEY_CMD_STCDRIFT: {
		RMuint32 STCModuleID = EMHWLIB_MODULE(STC, 0);
		RMuint32 stc_freq, xtal_freq, rounds;
		RMuint64 stc_curr;
		RMuint32 xtal_curr;
		RMint32 dist;
		static RMint32 initialdist = 0;
		enum ClockCounter ctr = ClockCounter_xtal_in;
		enum PLLSource xtal = PLLSource_xtal;
		
		err = RUAExchangeProperty(dcc_info->pRUA, PLL, RMPLLPropertyID_QuerySourceFrequency, 
			&xtal, sizeof(xtal), &xtal_freq, sizeof(xtal_freq));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get XTAL speed, %s\n", RMstatusToString(err));
		}
		err = RUAGetProperty(dcc_info->pRUA, STCModuleID, RMSTCPropertyID_StcTimeResolution, &stc_freq, sizeof(stc_freq));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get STC speed, %s\n", RMstatusToString(err));
		}
		fprintf(stderr, "STC running at %lu Hz, Xtal running at %lu Hz\n", stc_freq, xtal_freq);
		err = RUAExchangeProperty(dcc_info->pRUA, STCModuleID, RMSTCPropertyID_TimeInfo,
			&xtal_freq, sizeof(xtal_freq), &stc_curr, sizeof(stc_curr));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get STC, %s\n", RMstatusToString(err));
		}
		err = RUAExchangeProperty(dcc_info->pRUA, PLL, RMPLLPropertyID_QueryCounter,
			&ctr, sizeof(ctr), &xtal_curr, sizeof(xtal_curr));
		if (RMFAILED(err)) {
			fprintf(stderr, "Can not get XTAL, %s\n", RMstatusToString(err));
		}
		if (! initialdist) initialdist = xtal_curr - (RMuint32)stc_curr;
		xtal_curr -= initialdist;
		rounds = (xtal_curr + xtal_freq) / xtal_freq;
		dist = xtal_curr - (RMuint32)stc_curr;
		if ((RMuint32)(RMabs(dist)) > (RMuint32)(xtal_freq * 10)) initialdist = 0;
		fprintf(stderr, "stc:%lu - xtal:%lu = %ld, avrg: %ld ppm\n", 
			(RMuint32)stc_curr, xtal_curr, dist, 
			(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;
	case KEY_CMD_HDMI_CEC:
		if (dcc_info->dh_info && dcc_info->dh_info->pDH) {
			RMascii k;
			struct CEC_Frame cec;
			RMuint32 d;
			
			cec.Initiator = dcc_info->dh_info->cec_context[dcc_info->dh_info->DH_sel].Initiator;
			cec.Destination = 15;  // broadcast
			cec.Size = 1;
			cec.Opcode = CEC_Opcode_FeatureAbort;
			fprintf(stderr, "HMI CEC re-[c]alibrate, [s]tandby, [p]ing: ");
			k = RMGetKey(); fprintf(stderr, "'%c'\n", k);
			switch (k) {
			case 'c':
				DHCECCalibrate(dcc_info->dh_info->pDH);
				return RM_OK;
			case 's':
				cec.Opcode = CEC_Opcode_Standby;
				break;
			case 'p':
				cec.Size = 0;
				break;
			}
			fprintf(stderr, "HDMI CEC dest.(0:TV,1:Rec,5:Audio,F:Broadcast): ");
			k = RMGetKey(); fprintf(stderr, "%c\n", k);
			if ((k>='0')&&(k<='9')) d=k-'0'; else if ((k>='A')&&(k<='F')) d=k-'A'+10; else if ((k>='a')&&(k<='f')) d=k-'a'+10; else {fprintf(stderr, " Error\n"); break;}
			cec.Destination = d;
			
			fprintf(stderr, "From ");
			print_CEC_ID(cec.Initiator);
			fprintf(stderr, " to ");
			print_CEC_ID(cec.Destination);
			fprintf(stderr, "\n");
			err = DHCECSendMessage(dcc_info->dh_info->pDH, &cec);
		}
		break;
	default:
		*processed = FALSE;
	}
	return RM_OK;
}

RMstatus handle_key(struct dcc_context *dcc_info, RMuint32 *cmd, RMuint32 keyflags, RMascii key)
{
	RMstatus err;
	struct RM_PSM_Actions actions;
	
	actions.cmd = RM_UNKNOWN;
	
	if ((key == KEY_CMD_NONE1) || (key == KEY_CMD_NONE2)) {
		goto out_key;
	}
	
	if (keyflags & SET_KEY_DEBUG) {
		if (key == KEY_CMD_GET_DEBUG_INFO) {
			actions.cmd = KEY_CMD_GET_DEBUG_INFO;
			actions.cmdProcessed = FALSE;
			RMDBGLOG((DISABLE, "goto after debugKeys!\n"));
			goto out_key;
		} else {
			handle_debug_key(dcc_info, key, &(actions.cmdProcessed));
			if (actions.cmdProcessed) {
				RMDBGLOG((DISABLE, "goto after debugKeys!\n"));
				goto out_key;
			}
		}
	}
	
	if (keyflags & SET_KEY_PLAYBACK) {
		err = handle_playback_keys(dcc_info, &actions, key);
		if (err == RM_OK) {
			RMDBGLOG((DISABLE, "goto after playbackKeys!\n"));
			goto out_key;
		}
		else if (err != RM_NOTIMPLEMENTED) {
			RMDBGLOG((ENABLE, "handle_playback_keys returned error!\n"));
			return err;
		}
	}