process_key.c

1. 8623L平台

	else {
		RMDBGLOG((ENABLE, "ERROR: invalid PSMcontext\n"));
		return RM_ERROR;
	}


	/* we process all decoders */
	for (i = 0; i < PSMcontext->validPSMContexts; i++) {

		if ((PSMcontext->selectedPSMContextMask & (1<<i))) {
			RMDBGLOG((DISABLE, "processing decoder %lu\n", i+1));
			dcc_info = dcc_info_array[i];
		}
		else {
			RMDBGLOG((DISABLE, "decoder %lu skipped\n", i+1));
			continue;
		}
		
#ifdef _DEBUG
		oldstate = dcc_info->FSMstate;
#endif

		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_debug;
			} else {
				handle_debug_key(dcc_info, key, &(actions->cmdProcessed));
				if (actions->cmdProcessed) {
					RMDBGLOG((DISABLE, "goto after debugKeys!\n"));
					goto out_key_debug;
				}
			}
		}
	
		if (dcc_info->FSMstate == RM_PSM_Prebuffering) {
			if (key == KEY_CMD_QUIT) {
				fprintf(stderr, "Quitting during prebuffering...\n");
				actions->cmd = RM_QUIT;
				actions->cmdProcessed = FALSE;
				goto out_key;
			}
			else {
				fprintf(stderr, "commands other than 'quit' are not allowed while prebuffering, skip\n");
				return RM_OK;
			}
		}

		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;
			}
		}
	
		if (keyflags & SET_KEY_AUDIO) {
			if (handle_audio_keys(dcc_info, actions, key) == TRUE) {
				RMDBGLOG((DISABLE, "goto after audioKeys!\n"));
				goto out_key;
			}
		}

		if (keyflags & SET_KEY_DISPLAY) {
			err = handle_display_keys(dcc_info, actions, key);
			if (err == RM_OK) {
				RMDBGLOG((DISABLE, "goto after displayKeys!\n"));
				goto out_key;
			}
			else if (err != RM_NOTIMPLEMENTED) {
				RMDBGLOG((ENABLE, "handle_display_keys returned error!\n"));
				return err;
			}
		}

		if (keyflags & SET_KEY_SPI) {
			if (handle_spi_keys(dcc_info, actions, key) == TRUE) {
				RMDBGLOG((DISABLE, "goto after spiKeys!\n"));
				goto out_key;
			}
		}

		//RMDBGLOG((ENABLE, "unhandled key '%c', passing it to the application\n", key));
		actions->cmdProcessed = FALSE;
		keyProcessed = FALSE;

	
	out_key:


#ifdef _DEBUG
		if (keyProcessed) {
			char buffer[256];

			switch (dcc_info->FSMstate) {
			case RM_PSM_Playing:
				sprintf(buffer, "state is: playing");
				break;
			case RM_PSM_Stopped:
				sprintf(buffer, "state is: stopped");
				break;
			case RM_PSM_Paused:
				sprintf(buffer, "state is: paused");
				break;
			case RM_PSM_NextPic:
				sprintf(buffer, "state is: nextpic");
				break;
			case RM_PSM_Slow:
				sprintf(buffer, "state is: slow");
				break;
			case RM_PSM_Fast:
				sprintf(buffer, "state is: fast");
				break;
			case RM_PSM_IForward:
				sprintf(buffer, "state is: ifwd");
				break;
			case RM_PSM_IRewind:
				sprintf(buffer, "state is: irwd");
				break;
			case RM_PSM_Prebuffering:
				sprintf(buffer, "state is: prebuf");
				break;
			case RM_PSM_IPaused:
				sprintf(buffer, "state is: ipaused");
				break;
			case RM_PSM_INextPic:
				sprintf(buffer, "state is: inextpic");
				break;
			case RM_PSM_Rewind:
				sprintf(buffer, "state is: rewind");
				break;
			}
		
			if (dcc_info->FSMstate == oldstate)
				sprintf(buffer+strlen(buffer), " (unchanged)");

			RMDBGLOG((ENABLE, "%s\n", buffer));

				
			buffer[0] = '\0';
			if (actions->performedActions & RM_PSM_AUDIO_STOPPED)
				sprintf(buffer+strlen(buffer), "audioStopped, ");
			if (actions->performedActions & RM_PSM_VIDEO_STOPPED)
				sprintf(buffer+strlen(buffer), "videoStopped, ");
			if (actions->performedActions & RM_PSM_DEMUX_STOPPED)
				sprintf(buffer+strlen(buffer), "demuxStopped, ");
			if (actions->performedActions & RM_PSM_STC_STOPPED)
				sprintf(buffer+strlen(buffer), "stcStopped, ");

			if (actions->toDoActions & RM_PSM_FIRST_PTS)
				sprintf(buffer, "firstPTS, ");
			if (actions->toDoActions & RM_PSM_RESYNC_TIMER)
				sprintf(buffer+strlen(buffer), "resyncTimer, ");
			if (actions->toDoActions & RM_PSM_DEMUX_IFRAME)
				sprintf(buffer+strlen(buffer), "demuxIFrame, ");
			if (actions->toDoActions & RM_PSM_DEMUX_NORMAL)
				sprintf(buffer+strlen(buffer), "demuxNormal, ");
			if (actions->toDoActions & RM_PSM_FLUSH_VIDEO)
				sprintf(buffer+strlen(buffer), "flushVideo, ");
			if (actions->toDoActions & RM_PSM_NORMAL_PLAY)
				sprintf(buffer+strlen(buffer), "normalPlay, ");

			if (actions->cmdProcessed)
				sprintf(buffer+strlen(buffer), "cmdProcessed, ");
			if (actions->asyncCmdPending)
				sprintf(buffer+strlen(buffer), "asyncCmdPending, ");

			if (!strlen(buffer))
				sprintf(buffer, "none, ");

			if (((!actions->cmdProcessed) && 
			     (actions->cmd != RM_NONE) &&
			     (actions->cmd != RM_UNKNOWN)) ||
			    (actions->asyncCmdPending))
				sprintf(buffer+strlen(buffer), "(app_specific_cmd), ");

			RMDBGLOG((ENABLE, "flags: %s cmd=%lu, asyncCmd=%lu\n", buffer, (RMuint32)actions->cmd, (RMuint32)actions->asyncCmd));
		
		}

#endif //DEBUG
	out_key_debug:
		/* the key is application specific (rm_unknown) */
		if (!keyProcessed)
			break;
	}

	/* verify decoder status */
	stopped = 0;
	for ( i = 0; i < PSMcontext->validPSMContexts; i++) {
		if ((dcc_info_array[i]->FSMstate == RM_PSM_Stopped) || 
		    (dcc_info_array[i]->FSMstate == RM_PSM_Paused) ||
		    (dcc_info_array[i]->FSMstate == RM_PSM_IPaused)) {
			RMDBGLOG((DISABLE, "decoder %ld is %s\n", 
				  i+1, 
				  dcc_info_array[i]->FSMstate == RM_PSM_Stopped ? "stopped":"paused"));
			stopped++;
		}
	}

	if ((stopped == PSMcontext->validPSMContexts) && (actions->cmd == RM_NONE)) {
		RMDBGLOG((ENABLE, ">>> awaiting command\n"));
		goto get_key;
	}

	return RM_OK;
}

RMbool handle_spi_keys(struct dcc_context *dcc_info, struct RM_PSM_Actions *actions, RMascii key)
{
	actions->cmdProcessed = TRUE;

	switch (key) {
	case KEY_CMD_CHANGE_CHANNEL:
		actions->cmd = KEY_CMD_CHANGE_CHANNEL;
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_PAT_INFO:
		actions->cmd = KEY_CMD_PAT_INFO;
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_CHANGE_PMT:
		actions->cmd = KEY_CMD_CHANGE_PMT;
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_SWITCH_SPI_FILE:
		actions->cmd = KEY_CMD_SWITCH_SPI_FILE;
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_CHANGE_AUDIO: 
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_SWITCHAUDIO) {
			RMuint32 streamNumber;
				
			if (actions->asyncCmdPending) {
				fprintf(stderr, "there's a previous async cmd(%lu) pending, ignoring\n", actions->asyncCmd);
				actions->cmdProcessed = FALSE;
				break;
			}
				
			fprintf(stderr, "audio stream change (select mode)\n");
				
			fprintf(stderr, "switch to audio stream: ");
			RMTermGetUint32(&streamNumber);
			dcc_info->selectAudioStream = (RMint32) streamNumber;
				
			actions->asyncCmd = RM_AUDIO_STREAM_CHANGE;
			actions->asyncCmdPending = TRUE;
				
			actions->cmdProcessed = FALSE;
			break;
		}
		fprintf(stderr, "switchAudio command not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;
			
	case KEY_CMD_CHANGE_AUDIO_PID: 
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_SWITCHAUDIO) {
			actions->cmd = RM_AUDIO_STREAM_CHANGE;
			actions->cmdProcessed = FALSE;
			break;
		}

		fprintf(stderr, "switchAudio command not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;
			
	case KEY_CMD_CYCLE_AUDIO:
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_SWITCHAUDIO) {
			if (actions->asyncCmdPending) {
				fprintf(stderr, "there's a previous async cmd(%lu) pending, ignoring\n", actions->asyncCmd);
				actions->cmdProcessed = FALSE;
				break;
			}
				
			fprintf(stderr, "audio stream change (cycle mode)\n");
			dcc_info->selectAudioStream = -1;
					
			actions->asyncCmd = RM_AUDIO_STREAM_CHANGE;
			actions->asyncCmdPending = TRUE;
				
			actions->cmdProcessed = FALSE;
			break;
		}
		fprintf(stderr, "switchAudio command not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_NERO_NEXT_CHAPTER:
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_CHAPTERS) {
			RMDBGLOG((ENABLE,"advance to next chapter\n"));
		
			actions->cmd = RM_NERO_NEXT_CHAPTER;
			actions->cmdProcessed = FALSE;
			break;
		}
		fprintf(stderr, "chapters not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_NERO_PREV_CHAPTER:
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_CHAPTERS) {
			RMDBGLOG((ENABLE,"go to prev chapter\n"));
			
			actions->cmd = RM_NERO_PREV_CHAPTER;
			actions->cmdProcessed = FALSE;
			break;
		}
		fprintf(stderr, "chapters not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;
	case KEY_CMD_NERO_CYCLE_SUBTITLE:
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_SWITCHSUBTITLE) {
			RMDBGLOG((ENABLE,"switch subtitle\n"));
			
			actions->cmd = RM_NERO_SWITCH_SUBTITLE;
			actions->cmdProcessed = FALSE;
			break;
		}
		fprintf(stderr, "subtitles not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;

	case KEY_CMD_CHANGE_VIDEO:
		if (dcc_info->RM_PSM_commands & RM_PSM_ENABLE_SWITCHVIDEO) {
			actions->cmd = KEY_CMD_CHANGE_VIDEO;
			actions->cmdProcessed = FALSE;
			break;
		}
		fprintf(stderr, "switchVideo command not enabled!\n");
		actions->cmdProcessed = FALSE;
		break;
	default:
		actions->cmdProcessed = FALSE;
		return FALSE;
	}

	return TRUE;

}


RMstatus handle_display_keys(struct dcc_context *dcc_info, struct RM_PSM_Actions *actions, RMascii key)
{
	RMstatus err;
	RMbool update_out_window = FALSE;

	actions->cmdProcessed = TRUE; //will be set to false if we dont process the key

	switch (key) {
	case KEY_CMD_CONTRAST_PLUS:
	case KEY_CMD_CONTRAST_MINUS:
		if (dcc_info->disp_info == NULL) return RM_OK;
		if ((key == KEY_CMD_CONTRAST_PLUS) && (dcc_info->disp_info->contrast < 240))
			dcc_info->disp_info->contrast += 16;
		else if ((key == KEY_CMD_CONTRAST_MINUS) && (dcc_info->disp_info->contrast > 15))
			dcc_info->disp_info->contrast -= 16;

		fprintf(stderr, "Now contrast is %hu\n", dcc_info->disp_info->contrast);
			
		while ((err = RUASetProperty(dcc_info->pRUA, DispDigitalOut, RMGenericPropertyID_Co