play_capture_sampleapp.c

1. 8623L平台

			if (argi + 1 >= argc) goto SKIP;
			if (argv[argi + 1][0] == '-') goto SKIP;
			SCANPARAM(options->i2c_video_delay, "please specify a delay value", 1);
			options->i2c_audio1_delay = options->i2c_video_delay;
			options->i2c_audio2_delay = options->i2c_video_delay;
		}
		else if (! strcmp(&(argv[argi][1]), "update")) {
			options->update = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "gpiofid")) {
			options->use_gpio_fid = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "fidinv")) {
			options->invert_fid = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "eq")) {
			SCANPARAM(options->cable_eq, "please specify a cable length", 1);
			options->cable_eq &= 0x0F;
		}
		else if (! strcmp(&(argv[argi][1]), "fv")) {
			options->follow_vfreq = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "v")) {
			if (options->verbouse) options->intr_debug = TRUE;
			options->verbouse = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "bg")) {
			options->green_bg = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "pcm24")) {
			options->lpcm_24bit = TRUE;
		}
		else {
			err = RM_PENDING;
		}
	}
SKIP:
	if (err == RM_OK) 
		*index = argi + 1;
	
	return err;
}

static void show_usage(char *progname)
{
	show_local_options();
	show_display_options();
	show_capture_options();
	show_audio_options();
	fprintf(stderr, "--------------------------------\n");
	fprintf(stderr, "Minimum cmd line: %s -i video\n", progname);
	fprintf(stderr, "--------------------------------\n");
	
	exit(1);
}
static void parse_cmdline(int argc, char *argv[])
{
	int i;
	RMstatus err;
	RMbool do_show = FALSE;
	
	if (argc < 2) 
		show_usage(argv[0]);
	
	i = 1;
	while ((! do_show) && (argc > i)) {
		if (argv[i][0] == '-') {
			/* switch to second input with '--' */
			if (! strcmp(&(argv[i][1]), "-")) {
				input_num = 1;
				i++;
				err = RM_OK;
				continue;
			}
			
			err = parse_local_cmdline(argc, argv, &i, &local_opt[input_num]);
			if (err != RM_PENDING) {
				if (RMFAILED(err)) {
					printf("failed in local option: %s\n", argv[i]);
					do_show = TRUE;
				}
				continue;
			}
			
			err = parse_display_cmdline(argc, argv, &i, &disp_opt);
			if (err != RM_PENDING) {
				if (RMFAILED(err)) {
					printf("failed in display option: %s\n", argv[i]);
					do_show = TRUE;
				}
				continue;
			}
			
			err = parse_capture_cmdline(argc, argv, &i, &capture_opt[input_num]);
			if (err != RM_PENDING) {
				if (RMFAILED(err)) {
					printf("failed in capture option: %s\n", argv[i]);
					do_show = TRUE;
				}
				continue;
			}
			
			err = parse_audio_cmdline(argc, argv, &i, &audio_opt);
			if (err != RM_PENDING) {
				if (RMFAILED(err)) {
					printf("failed in audio option: %s\n", argv[i]);
					do_show = TRUE;
				}
				continue;
			}
			
			printf("unknown option: %s\n", argv[i]);
			err = RM_ERROR;
			do_show = TRUE;
		}
	}
	if (do_show) show_usage(argv[0]);
}

struct capture_context {
	struct dcc_context *dcc_info;
	// TODO etc.
} sampleapp_capture_context;

static RMstatus sampleapp_callback_func(void *pContext, struct capsam_update *pUpdate)
{
	//struct capture_context *pCapture = (struct capture_context *)pContext;
	
	// TODO: modify *pUpdate, if needed
	
	return RM_OK;
}

static void cleanup(void *param)
{
	RMDBGLOG((ENABLE, "%s\n",__func__));
	if (pInstance) {
		RUADestroyInstance(pInstance);
		pInstance = NULL;
	}
}

int main(int argc, char *argv[])
{
	RMstatus err;
	struct DCC *pDCC = NULL;
	static struct dcc_context dcc_info;
	struct display_context disp_info;
	struct dh_context dh_info;
	RMbool run = TRUE;
	struct capsam_main_instance *capsam_main = NULL;
	enum capsam_video_input video_input_port = capsam_video_input_none;
	enum capsam_audio_input audio_input_port = capsam_audio_input_none;
	
	RMMemset(&dcc_info, 0, sizeof(struct dcc_context));
	RMMemset(&disp_info, 0, sizeof(struct display_context));
	RMMemset(&dh_info, 0, sizeof(struct dh_context));

	local_opt[0].output_window = &(disp_info.osd_window[0]);
	init_local_options(&local_opt[0]);
	local_opt[1].output_window = &(disp_info.osd_window[1]);
	init_local_options(&local_opt[1]);
	init_display_options(&disp_opt);
	init_capture_options(&capture_opt[0]);
	init_capture_options(&capture_opt[1]);
	init_audio_options(&audio_opt);
	disp_opt.dh_info = &dh_info;
	audio_opt.dh_info = &dh_info;
	
	parse_cmdline(argc, argv);
	
	RMSignalInit(cleanup, NULL);  // catch all temination signals, call RMTermInit() and cleanup(), then exit(0).
	
	if (RMFAILED(err = RUACreateInstance(&pInstance, chip_num))) {
		printf("Error creating instance! %s\n", RMstatusToString(err));
		exit(1);
	}

	err = DCCOpen(pInstance, &pDCC);
	if (RMFAILED(err)) {
		fprintf(stderr, "Error Opening DCC! %s\n", RMstatusToString(err));
		return -1;
	}
	err = DCCInitMicroCodeEx(pDCC, disp_opt.init_mode);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot initialize microcode! %s\n", RMstatusToString(err));
		return -1;
	}

	dcc_info.chip_num = chip_num;
	dcc_info.pRUA = pInstance;
	dcc_info.pDCC = pDCC;
	dcc_info.route = (capture_opt[0].InputModuleID == DispColorBars) ? DCCRoute_ColorBars : DCCRoute_Main; // TODO use op.RouteModuleID
	dcc_info.scc = NULL;
	dcc_info.rtk = NULL;
	dcc_info.state = RM_PLAYING;
	dcc_info.trickmode_id = RM_NO_TRICKMODE;
	dcc_info.seek_supported = FALSE;
	dcc_info.disp_info = &disp_info;
	dcc_info.pStcSource = NULL;
	dcc_info.pAudioSource = NULL;
	set_default_out_window(&(dcc_info.disp_info->out_window));

	err = apply_display_options(&dcc_info, &disp_opt);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot set display opions! %s\n", RMstatusToString(err));
		goto cleanup;
	}

#if 0
	DTV8624[0].chip_hdmi_config.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	DTV8624[0].chip_analog_video_config.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	DTV8624[0].chip_analog_audio_config.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	DTV8624[0].chip_analog_audio_config2.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);

	DTV8634[0].chip_hdmi_config.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	DTV8634[0].chip_analog_video_config.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	DTV8634[0].chip_analog_audio_config.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	DTV8634[0].chip_analog_audio_config2.I2CModuleID = EMHWLIB_MODULE(I2C, local_opt[0].i2c_module);
	printf("\n\n\n\n %ld \n", DTV8624[0].chip_analog_video_config.I2CModuleID );
#endif

	// open capture instance
	err = capsam_main_open(&dcc_info, &capsam_main, &disp_opt, &capture_opt[0], &audio_opt);
	if (RMFAILED(err) || (capsam_main == NULL)) {
		fprintf(stderr, "Failed to create instance of the capture! %s\n", RMstatusToString(err));
		goto cleanup;
	}
	
	// register callback function
	sampleapp_capture_context.dcc_info = &dcc_info;
	err = capsam_main_register_callback(capsam_main, &sampleapp_callback_func, &sampleapp_capture_context);

	// initialize all capture chips
	err = capsam_main_initialize_chips(capsam_main, DTV8624_VideoChipInfoSample, DTV8624_AudioChipInfoSample);

	// select and initialize current input port
#if 0
	switch(local_opt[0].i2c_port){
	case capsam_Direct: 
	case capsam_CVBS1: 
	case capsam_CVBS2: 
	case capsam_SVideo1: 
	case capsam_SVideo2:
	case capsam_ScartCVBS1: 
	case capsam_ScartCVBS2: 
	case capsam_ScartRGB1: 
	case capsam_ScartRGB2: 
	case capsam_Tuner1: 
	case capsam_Tuner2: 
	case capsam_Component1: 
	case capsam_Component2: 
	case capsam_VGA: 
		err = capsam_main_select_input(capsam_main,capsam_access_type_analog,DTV8634);
		break;
	case capsam_HDMI0: 
	case capsam_HDMI1: 
		err = capsam_main_select_input(capsam_main,capsam_access_type_hdmi,DTV8634);
		break;
	default:
		err = RM_ERROR;	
		break;
	}
#endif
	// convert old enum to new enum
	switch(local_opt[0].i2c_port){
	case capsam_Direct: 
	case capsam_CVBS1: 
	case capsam_CVBS2: 
	case capsam_SVideo1: 
	case capsam_SVideo2:
	case capsam_ScartCVBS1: 
	case capsam_ScartCVBS2: 
	case capsam_ScartRGB1: 
	case capsam_ScartRGB2: 
	case capsam_Tuner1: 
	case capsam_Tuner2: 
	case capsam_Component1: 
		video_input_port = capsam_video_input_component1;
		audio_input_port = capsam_audio_input_stereo1;
		break;
	case capsam_Component2: 
		video_input_port = capsam_video_input_component2;
		audio_input_port = capsam_audio_input_stereo1;
		break;
	case capsam_VGA: 
		video_input_port = capsam_video_input_vga;
		audio_input_port = capsam_audio_input_stereo1;
		break;
	case capsam_HDMI0:
		video_input_port = capsam_video_input_hdmi1;
		audio_input_port = capsam_audio_input_hdmi1;
		break;
	case capsam_HDMI1: 
		video_input_port = capsam_video_input_hdmi2;
		audio_input_port = capsam_audio_input_hdmi2;
		break;
	default:
		err = RM_ERROR;	
		break;
	}

	// when DTV8624 board
	err = capsam_main_initialize_input(capsam_main,
					video_input_port, 
					DTV8624_VideoInputMapSample,
					audio_input_port,
					DTV8624_AudioInputMapSample);	
	
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to select input: %s\n", RMstatusToString(err));
		err = capsam_main_close(capsam_main);		
		goto cleanup;
	}
	
	RMTermInit(TRUE);    // don't allow ctrl-C and the like ...
	RMSignalInit(NULL, NULL);  // ... but catch other termination signals to call RMTermExit(), but not RUADestroyInstance()

	while(run){
		RMuint32 cmd;
		RMascii key;
		
		if (RMGetKeyNoWait(&key)) {
			err = handle_key(&dcc_info, &cmd, SET_KEY_DEBUG | SET_KEY_AUDIO, key);
			if (cmd == RM_QUIT) run = FALSE;
			
			if (0) {  // e.g. if other input is selected
				err = capsam_main_close_input(capsam_main);
				if (RMFAILED(err)) {
					fprintf(stderr, "Failed to close input: %s\n", RMstatusToString(err));
				}
				//err = capsam_main_select_input(capsam_main, &(VideoInput[1]));
				if (RMFAILED(err)) {
					fprintf(stderr, "Failed to select input: %s\n", RMstatusToString(err));
				}
			}
		}
		
		err = capsam_main_loop(capsam_main);
		
		usleep(100000);
	}
		
	err = capsam_main_close_input(capsam_main);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to close input: %s\n", RMstatusToString(err));
	}
	
	err = capsam_main_close(capsam_main);
	capsam_main = NULL;
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to close capture instance: %s\n", RMstatusToString(err));
	}

	////////////////////////////////////////////////////////////////////////
	// Closing 
	////////////////////////////////////////////////////////////////////////
 cleanup:
	RMTermExit();
	
	clear_display_options(&dcc_info, &disp_opt);
	
	err = DCCClose(pDCC);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot close DCC %d\n", err);
	}	
	
	cleanup(NULL);	

	return 0;
}