process_key.c

1. 8623L平台

//	Y = Display Info                        y = Manu test (?!?)
//	Z = debug vsync time diff               z = Stop
//	  = Pause
//------------------------------------------------------------------------------

void display_key_usage(RMuint32 keyflags)
{
 	if (verbose_stderr == 0)
 		return;
 
	fprintf(stderr, "\nInteractive keyboard commands:\n");
	fprintf(stderr, "  q: Quit\n");
	
	if (keyflags & SET_KEY_PLAYBACK) 
		fprintf(stderr, "Playback commands:\n"
			"  s,z - Stop, p - Play, <space> - Pause, n - Next picture (after PAUSE only) \n"
			"  + increase speed, - decrease speed, = set speed\n"
			"  ] Forward I-frame 1x, [ Backward I-frame 1x, R rewind (if supported, adjust speed with +/-)\n"
			"  f: seek (if supported)\n");
	
	if (keyflags & SET_KEY_DISPLAY)
		fprintf(stderr, "Display commands:\n"
			"  c/C: decrease/increase contrast\n"
			"  b/B: decrease/increase brightness\n"
			"  t/T: decrease/increase saturation\n"
			"  h/H: decrease/increase\n"
			"  x: toggle video output enable/disable\n"
			"  7: full screen scaler size, 1: half scaler size\n"
			"  3/9: decrease/increase scaler size\n"
			"  2,4,6,8: move scaler window (use numerical key block)\n"
			"  5: switch from VIDEO to OSD control (valid only if OSD is present)\n"
			"  w: change non-linear width\n"
			"  W: change non-linear level\n"
			"  d: Dump OSD Info\n"
			"  r: rotate picture\n");

	if (keyflags & SET_KEY_SPI) 
		fprintf(stderr, "SPI commands:\n"
			"  k - SPI channel change\n"
			"  i - SPI PAT info\n"
			"  m - SPI PMT change\n"
			"  A - SPI audio stream change\n"
			"  X - SPI video stream change\n"
			"  a - Cycle through audio streams\n"
			"  l - Choose audio stream\n"
			"  K - switch between spi and file playback\n");
	
	if (keyflags & SET_KEY_AUDIO) 
		fprintf(stderr, "Audio commands:\n"
			"  v: decrease volume - V: increase volume - _: mute\n"
			"  E: toggle between dual modes (Stereo->LeftMono->RightMono->Mono)\n"
			"  <, >: decrease/increase playback speed by 1 ppm\n");
	
	if (keyflags & SET_KEY_DEBUG) 
		fprintf(stderr, "Debug commands:\n"
			"  gr<A>: read 32 bits (1 dword) from gbus address A (hex)\n"
			"  gw<A> <D>: write D (hex) to gbus address A (hex)\n"
			"  gd<A> <N>: read N (hex) dwords from gbus address A (hex)\n"
			"  gf<A>: measure frequency of the 32 bit register at gbus address A (hex)\n"
			"  I: enter I2C debug access mode (HDMI only)\n"
			"  M: enter video mode modificator\n"
			"  |: print STC drift information\n"
			"  !: show debug informations\n"
			"  Y: show display debug informations\n"
			"  Z: show vsync debug information\n"
			"  o: show vsync debug probes:\n"
			"     o<N>: probe gbus address DebugProbeN repeatedly\n"
			"     oo: probe DebugProbe0 through DebugProbe7 once\n"
			"     oc: probe all current color spaces\n"
			"  *: force filter settings on main video scaler\n"
			"  #: Turn HDCP on/off (HDMI only)\n"
			"  %%: Send HDMI CEC message\n");
	
	fprintf(stderr, "\n");
}

static void print_hz(RMuint32 f) 
{
	if (f >= 1000000) fprintf(stderr, "%3lu,%03lu,%03lu", f / 1000000, (f / 1000) % 1000, f % 1000);
	else if (f >= 1000) fprintf(stderr, "%7lu,%03lu", f / 1000, f % 1000);
	else fprintf(stderr, "%11lu", f);
}

static RMuint32 get_freqency(
	struct gbus *pGBus, 
	RMuint32 addr, 
	RMuint32 uSecDelay)
{
	RMuint32 ref0, ref1, refd, ctr0, ctr1, ctrd;
	
	/* avoid integer overflow */
	if (uSecDelay > 159) uSecDelay = 159;
	
	/* initial counter values */
	ref0 = gbus_read_uint32(pGBus, 0x10048);  // REG_BASE_system_block + SYS_xtal_in_cnt
	ctr0 = gbus_read_uint32(pGBus, addr);
	
	/* loop for specified time, at least once */
	do {
		/* final counter values */
		ref1 = gbus_read_uint32(pGBus, 0x10048);  // REG_BASE_system_block + SYS_xtal_in_cnt
		ctr1 = gbus_read_uint32(pGBus, addr);
		
		/* delta values */
		refd = (ref1 > ref0) ? ref1 - ref0 : 0xFFFFFFFF - ref0 + ref1 + 1;
		ctrd = (ctr1 > ctr0) ? ctr1 - ctr0 : 0xFFFFFFFF - ctr0 + ctr1 + 1;
		
		/* check if xtal_in_ctr is stagnant */
		if (! refd) return 0;
	} while (refd < XTAL_HZ * uSecDelay / 1000);
	
	/* return ctrd, normalized to Hz */
	return (RMuint32)RM64mult32div32(ctrd, XTAL_HZ, refd);
}

RMstatus process_key(struct dcc_context *dcc_info, RMuint32 *cmd, RMuint32 keyflags)
{
	RMascii key;
	RMstatus err;

 in_key:	
	
	key = 0;
	if (((dcc_info->state == RM_STOPPED) || (dcc_info->state == RM_PAUSED)) || (RMKeyAvailable())) 
		key = RMGetKey();
	
	err = handle_key(dcc_info, cmd, keyflags, key);
	if (err == RM_PENDING) err = RM_OK;
	
	if (RMSUCCEEDED(err) && (*cmd == RM_UNKNOWN) && ((dcc_info->state == RM_STOPPED) || (dcc_info->state == RM_PAUSED))) {
		goto in_key;
	}
	
	return err;
}

/* prototypes required for process_command() */
RMbool handle_audio_keys(struct dcc_context *dcc_info, struct RM_PSM_Actions *actions, RMascii key);
RMbool handle_spi_keys(struct dcc_context *dcc_info, struct RM_PSM_Actions *actions, RMascii key);
RMstatus handle_playback_keys(struct dcc_context *dcc_info, struct RM_PSM_Actions *actions, RMascii key);
RMstatus handle_display_keys(struct dcc_context *dcc_info, struct RM_PSM_Actions *actions, RMascii key);
RMstatus handle_debug_key(struct dcc_context *dcc_info, RMascii key, RMbool *processed);
void send_hilight_button(struct dcc_context *dcc_info);

static void print_CEC_ID(RMuint32 id) 
{
	switch (id) {
		case 0: fprintf(stderr, "TV"); break;
		case 1: fprintf(stderr, "Rec1"); break;
		case 2: fprintf(stderr, "Rec2"); break;
		case 3: fprintf(stderr, "Tuner1"); break;
		case 4: fprintf(stderr, "Play1"); break;
		case 5: fprintf(stderr, "Audio"); break;
		case 6: fprintf(stderr, "Tuner2"); break;
		case 7: fprintf(stderr, "Tuner3"); break;
		case 8: fprintf(stderr, "Play2"); break;
		case 9: fprintf(stderr, "Rec3"); break;
		case 10: fprintf(stderr, "Tuner4"); break;
		case 11: fprintf(stderr, "Play3"); break;
		case 14: fprintf(stderr, "Free"); break;
		case 15: fprintf(stderr, "Broadcast"); break;
		default: fprintf(stderr, "Reserved%lX", id); break;
	}
}

RMstatus handle_debug_key(struct dcc_context *dcc_info, RMascii key, RMbool *processed)
{
	static RMuint32 last_gr = 0;
	RMstatus err;
	
	*processed = TRUE;
	
	// Debug access to HDMI I2C busses
	if (dcc_info->dh_info && dcc_info->dh_info->pDH) {
		err = DHDebugI2C(dcc_info->dh_info->pDH, KEY_CMD_I2C, key);
		if (RMSUCCEEDED(err)) return RM_OK; //we processed the key
	}
	
	switch (key) {
	case KEY_CMD_GBUS: {
		RMascii k;
		fprintf(stderr, "%c", key);
		k = RMGetKey(); fprintf(stderr, "%c", k);
		if ((k == 'r') || (k == 'w') || (k == 'd') || (k == 'f')) {
			RMascii command = k;
			RMbool error = FALSE;
			RMuint32 a = 0, d = 0, i;
			RMascii device[40];
			struct llad *pLLAD;
			struct gbus *pGBus;
			RMPrintAscii(device, "%lu", dcc_info->chip_num);
			pLLAD = llad_open(device);
			pGBus = gbus_open(pLLAD);
			fprintf(stderr, " 0x");
			do {
				k = RMGetKey(); fprintf(stderr, "%c", k);
				if ((k >= '0') && (k <= '9')) a = (a << 4) + (k - '0'); 
				else if ((k >= 'A') && (k <= 'F')) a = (a << 4) + (k - 'A' + 10); 
				else if ((k >= 'a') && (k <= 'f')) a = (a << 4) + (k - 'a' + 10); 
				else if ((k == '\b') || (k == '\177')) a >>= 4; 
				else {
					if ((k != ' ') && (k != '\n')) error = TRUE; 
					break;
				}
			} while (!(a & 0xF0000000));
			if ((! error) && ((command == 'r') || (command == 'f'))) {
				if (! a) {
					a = last_gr;
					fprintf(stderr, "%08lX", a);
				} else last_gr = a;
				if (command == 'r') {
					fprintf(stderr, " = %08lX\n", gbus_read_uint32(pGBus, a));
				} else {
					fprintf(stderr, " @ ");
					print_hz(get_freqency(pGBus, a, 100));
					fprintf(stderr, " Hz\n");
				}
				k = '\n';
			} else if ((! error) && ((command == 'w') || (command == 'd'))) {
				fprintf(stderr, "0x");
				do {
					k = RMGetKey(); fprintf(stderr, "%c", k);
					if ((k >= '0') && (k <= '9')) d = (d << 4) + (k - '0'); 
					else if ((k >= 'A') && (k <= 'F')) d = (d << 4) + (k - 'A' + 10); 
					else if ((k >= 'a') && (k <= 'f')) d = (d << 4) + (k - 'a' + 10); 
					else if ((k == '\b') || (k == '\177')) d >>= 4; 
					else {
						if ((k != ' ') && (k != '\n')) error = TRUE; 
						break;
					}
				} while (!(d & 0xF0000000));
				if (! error) {
					if (command == 'w') {
						gbus_write_uint32(pGBus, a, d);
					} else if (command == 'd') {
						if (k != '\n') fprintf(stderr, "\n");
						k = '\n';
						for (i = a; i < a + d * 4; i += 4) {
							fprintf(stderr, "%08lX = %08lX\n", i, gbus_read_uint32(pGBus, i));
						}
					}
				}
			} else if (! error) {
				fprintf(stderr, " unknown command: g%c\n", command);
			}
			if (error) fprintf(stderr, " input error!\n");
			gbus_close(pGBus);
			llad_close(pLLAD);
		}
		if (k != '\n') fprintf(stderr, "\n");
		break;
	}
	case KEY_CMD_VSYNCPROBE: {
		RMascii k;
		RMuint32 d;
		RMascii device[40];
		struct llad *pLLAD;
		struct gbus *pGBus;
		fprintf(stderr, "DebugProbe ");
		k = RMGetKey(); fprintf(stderr, "%c", k);
		if (k == KEY_CMD_VSYNCPROBE) {  // 'oo': probe all probes once
			d=99;
		} else if (k == 'c') {  // probe color spaces
			enum EMhwlibColorSpace color_space;
			RMuint32 surface;
			struct DisplayBlock_SurfaceInfo_out_type surface_info;
			fprintf(stderr, "\nColor Spaces:\n");
			err = RUAGetProperty(dcc_info->pRUA, DispMainVideoScaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
			if (RMSUCCEEDED(err) && surface) err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo, &surface, sizeof(surface), &surface_info, sizeof(surface_info));
			fprintf(stderr, "- MainVideoScaler: %s\n", (RMSUCCEEDED(err)) ? (surface ? GetColorSpaceName(surface_info.ColorSpace) : "No Surface!") : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispOSDScaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
			if (RMSUCCEEDED(err) && surface) err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo, &surface, sizeof(surface), &surface_info, sizeof(surface_info));
			fprintf(stderr, "- OSDScaler: %s\n", (RMSUCCEEDED(err)) ? (surface ? GetColorSpaceName(surface_info.ColorSpace) : "No Surface!") : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispVCRMultiScaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
			if (RMSUCCEEDED(err) && surface) err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo, &surface, sizeof(surface), &surface_info, sizeof(surface_info));
			fprintf(stderr, "- VCRMultiScaler: %s\n", (RMSUCCEEDED(err)) ? (surface ? GetColorSpaceName(surface_info.ColorSpace) : "No Surface!") : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispCRTMultiScaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
			if (RMSUCCEEDED(err) && surface) err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo, &surface, sizeof(surface), &surface_info, sizeof(surface_info));
			fprintf(stderr, "- CRTMultiScaler: %s\n", (RMSUCCEEDED(err)) ? (surface ? GetColorSpaceName(surface_info.ColorSpace) : "No Surface!") : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispGFXMultiScaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
			if (RMSUCCEEDED(err) && surface) err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo, &surface, sizeof(surface), &surface_info, sizeof(surface_info));
			fprintf(stderr, "- GFXMultiScaler: %s\n", (RMSUCCEEDED(err)) ? (surface ? GetColorSpaceName(surface_info.ColorSpace) : "No Surface!") : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispSubPictureScaler, RMGenericPropertyID_Surface, &surface, sizeof(surface));
			if (RMSUCCEEDED(err) && surface) err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo, &surface, sizeof(surface), &surface_info, sizeof(surface_info));
			fprintf(stderr, "- SubPictureScaler: %s\n", (RMSUCCEEDED(err)) ? (surface ? GetColorSpaceName(surface_info.ColorSpace) : "No Surface!") : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispMainMixer, RMGenericPropertyID_ColorSpace, &color_space, sizeof(color_space));
			fprintf(stderr, "- MainMixer: %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispVCRMixer, RMGenericPropertyID_ColorSpace, &color_space, sizeof(color_space));
			fprintf(stderr, "- VCRMixer: %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispDigitalOut, RMGenericPropertyID_ColorSpace, &color_space, sizeof(color_space));
			fprintf(stderr, "- DigitalOut: %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispMainAnalogOut, RMGenericPropertyID_ColorSpace, &color_space, sizeof(color_space));
			fprintf(stderr, "- MainAnalogOut: %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispMainAnalogOut, RMDispMainAnalogOutPropertyID_ColorSpaceCVBS, &color_space, sizeof(color_space));
			fprintf(stderr, "- MainAnalogOut(CVBS): %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispComponentOut, RMGenericPropertyID_ColorSpace, &color_space, sizeof(color_space));
			fprintf(stderr, "- ComponentOut: %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			err = RUAGetProperty(dcc_info->pRUA, DispCompositeOut, RMGenericPropertyID_ColorSpace, &color_space, sizeof(color_space));
			fprintf(stderr, "- CompositeOut: %s\n", (RMSUCCEEDED(err)) ? GetColorSpaceName(color_space) : RMstatusToString(err));
			break;
		} else {  // probe one probe over and over
			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;}
		}
		sprintf(device, "%lu", dcc_info->chip_num);
		pLLAD = llad_open(device);
		pGBus = gbus_open(pLLAD);
		if (d < 16) {
			d = d * 4 + 0x00061FD0;  // DEBUG_PROBE0
			fprintf(stderr, " @ 0x%08lX:\n", d);
			do {
				fprintf(stderr, "  0x%08lX\r", gbus_read_uint32(pGBus, d));
			} while (! RMGetKeyNoWait(&k));
			fprintf(stderr, "\n");
		} else {
			fprintf(stderr, "\n");
			for (d = 0x00061FD0; d < 0x00061FF0; d += 4) {
				fprintf(stderr, "  0x%08lX: 0x%08lX\n", d, gbus_read_uint32(pGBus, d));
			}
		}
		gbus_close(pGBus);
		llad_close(pLLAD);
		break;
		}
	case KEY_CMD_VIDEOMODE: {
		struct VideoMode VM;
		RMascii k;
		RMuint32 *mod;
		err = get_current_video_mode(dcc_info, &VM);
		if (RMFAILED(err)) break;
		do {
			mod = NULL;
			fprintf(stderr, "Current video mode: (press corresponding key to modify value)\n");
			fprintf(stderr, "  [a] PixelClock:     %lu\n", VM.PixelClock);
			fprintf(stderr, "  [b] HActive:        %lu\n", VM.HActive);
			fprintf(stderr, "  [c] HFrontPorch:    %lu\n", VM.HFrontPorch);
			fprintf(stderr, "  [d] HSyncWidth:     %lu\n", VM.HSyncWidth);
			fprintf(stderr, "  [e] HBackPorch:     %lu\n", VM.HBackPorch);
			fprintf(stderr, "  [f] HSyncPolarity:  %s\n", VM.HSyncPolarity ? "positive" : "negative");
			fprintf(stderr, "  [g] VActive:        %lu\n", VM.VActive);
			fprintf(stderr, "  [h] VFrontPorch:    %lu\n", VM.VFrontPorch);
			fprintf(stderr, "  [i] VSyncWidth:     %lu\n", VM.VSyncWidth);
			fprintf(stderr, "  [j] VBackPorch:     %lu\n", VM.VBackPorch);
			fprintf(stderr, "  [k] VSyncPolarity:  %s\n", VM.VSyncPolarity ? "positive" : "negative");
			fprintf(stderr, "  [l] Interlaced:     %s\n", VM.Interlaced ? "yes" : "no");
			fprintf(stderr, "  <enter> to quit\n");
			k = RMGetKey();
			if (k == '\n') {
				RMuint32 HTotal, VTotal;
				HTotal = VM.HActive + VM.HFrontPorch + VM.HSyncWidth + VM.HBackPorch;
				VTotal = VM.VActive + VM.VFrontPorch + VM.VSyncWidth + VM.VBackPorch;
				if (VM.Interlaced) VTotal = VTotal * 2 + 1;
				fprintf(stderr, "New mode line for vesa.tbl:\n"
					"%9lu, %4lu, %4lu, %4lu, %3lu, %3lu, %3lu, %d, %4lu, %2lu, %2lu, %2lu, %d, NewMode_%lux%lux%lu%s\n", 
					VM.PixelClock, VM.HActive, VM.VActive, 
					HTotal, VM.HFrontPorch, VM.HSyncWidth, VM.HBackPorch, VM.HSyncPolarity, 
					VTotal, VM.VFrontPorch, VM.VSyncWidth, VM.VBackPorch, VM.VSyncPolarity, 
					VM.HActive, VM.VActive, 
					VM.PixelClock / (VTotal * HTotal), 
					VM.Interlaced ? "i" : "");
				break;
			}
			fprintf(stderr, "%c\n", k);
			switch (k) {
			case 'a': mod = &VM.PixelClock; break;