play_rmcapture.c

1. 8623L平台

	rmcapture_options->ov_top = capture_opt->ov_top;  // how much to add for overscan capture
	rmcapture_options->ov_bot = capture_opt->ov_bot;
	rmcapture_options->ov_lft = capture_opt->ov_lft;
	rmcapture_options->ov_rgt = capture_opt->ov_rgt;
	rmcapture_options->PictureAspectRatio = capture_opt->PictureAspectRatio; 
	rmcapture_options->PixelAspectRatio = capture_opt->PixelAspectRatio; 
	rmcapture_options->DeInt = capture_opt->DeInt;  // TRUE: allocate one extra picture buffer to perform motion-adaptive de-interlacing
	rmcapture_options->UseV2Pads = capture_opt->UseV2Pads;
	rmcapture_options->disablescaler = capture_opt->disablescaler;
	rmcapture_options->override = capture_opt->override;
	rmcapture_options->force_afd = local_opt->force_active_format || local_opt->force_wide_screen;  // TRUE: use 'afd' for the input afd
	rmcapture_options->afd.ActiveFormatValid = local_opt->force_active_format;
	rmcapture_options->afd.ActiveFormat = local_opt->active_format;
	rmcapture_options->afd.FrameAspectRatio.X = local_opt->wide_screen ? 16 : 4;
	rmcapture_options->afd.FrameAspectRatio.Y = local_opt->wide_screen ? 9 : 3;
	rmcapture_options->zoom_force = local_opt->zoom_force;
	rmcapture_options->zoom_x = local_opt->zoom_x;
	rmcapture_options->zoom_y = local_opt->zoom_y;
	rmcapture_options->zoom_w = local_opt->zoom_w;
	rmcapture_options->zoom_h = local_opt->zoom_h;
	rmcapture_options->force_overscan_crop = local_opt->force_overscan_crop;
	rmcapture_options->overscan_crop_amount = local_opt->overscan_crop_amount;
	rmcapture_options->overscan_crop = local_opt->overscan_crop;  // percentage of frame size to crop around edge for overscanned pictures
	rmcapture_options->enable_i2c_cc = local_opt->enable_i2c_cc;
	rmcapture_options->enable_i2c_wss = local_opt->enable_i2c_wss;
	rmcapture_options->i2c_cc = local_opt->i2c_cc;
	rmcapture_options->use_gpio_fid = local_opt->use_gpio_fid;
	rmcapture_options->invert_fid = local_opt->invert_fid;
	rmcapture_options->break_hdcp = local_opt->break_hdcp;
	rmcapture_options->cable_eq = local_opt->cable_eq;
	rmcapture_options->follow_vfreq = local_opt->follow_vfreq;
	rmcapture_options->green_bg = local_opt->green_bg;
	
	// VBI data
	rmcapture_options->vbi_x = capture_opt->vbi_x;
	rmcapture_options->vbi_y = capture_opt->vbi_y;
	rmcapture_options->vbi_w = capture_opt->vbi_w;
	rmcapture_options->vbi_h = capture_opt->vbi_h;
	rmcapture_options->vbiraw_topstart = capture_opt->vbiraw_topstart;
	rmcapture_options->vbiraw_topmask = capture_opt->vbiraw_topmask;
	rmcapture_options->vbiraw_botstart = capture_opt->vbiraw_botstart;
	rmcapture_options->vbiraw_botmask = capture_opt->vbiraw_botmask;
	rmcapture_options->vbianc_enable = capture_opt->vbianc_enable;
	rmcapture_options->vbianc_w = capture_opt->vbianc_w;
	rmcapture_options->vbianc_h = capture_opt->vbianc_h;
	rmcapture_options->vbianc_ytop = capture_opt->vbianc_ytop;
	rmcapture_options->vbianc_ybot = capture_opt->vbianc_ybot;
	rmcapture_options->vbi_buf = capture_opt->vbi_buf;
	rmcapture_options->vbi_size = capture_opt->vbi_size;
	rmcapture_options->vbi_dma = capture_opt->vbi_dma;
	
	// Audio
	rmcapture_options->AudioEngineID = audio_opt->AudioEngineID;
	rmcapture_options->AudioDecoderID = audio_opt->AudioDecoderID;
	rmcapture_options->SampleRate = audio_opt->SampleRate;
	rmcapture_options->audio_free_run = capture_opt->audio_free_run;
	rmcapture_options->Codec = audio_opt->Codec;
	rmcapture_options->SubCodec = audio_opt->SubCodec;
	rmcapture_options->AACParams = audio_opt->AACParams;
	rmcapture_options->DVDAParams = audio_opt->DVDAParams;
	rmcapture_options->BSACParams = audio_opt->BSACParams;
	rmcapture_options->Ac3Params = audio_opt->Ac3Params;
	rmcapture_options->DtsParams = audio_opt->DtsParams;
	rmcapture_options->MpegParams = audio_opt->MpegParams;
	rmcapture_options->LpcmVobParams = audio_opt->LpcmVobParams;
	rmcapture_options->LpcmAobParams = audio_opt->LpcmAobParams;
	rmcapture_options->LpcmBDParams = audio_opt->LpcmBDParams;
	rmcapture_options->PcmCdaParams = audio_opt->PcmCdaParams;
	rmcapture_options->PCMXParams = audio_opt->PCMXParams;
	rmcapture_options->WmaParams = audio_opt->WmaParams;
	rmcapture_options->TToneParams = audio_opt->TToneParams; 
	rmcapture_options->AudioGuardTime = capture_opt->AudioGuardTime;
	rmcapture_options->CaptureSource = audio_opt->CaptureSource;
	rmcapture_options->CaptureBitstream = audio_opt->CaptureBitstream;
	rmcapture_options->CaptureType = audio_opt->CaptureType;
	rmcapture_options->CaptureDelay = audio_opt->CaptureDelay;
	rmcapture_options->ExternalClk = audio_opt->ExternalClk;
	rmcapture_options->ExternalClkFreq = audio_opt->ExternalClkFreq;
	rmcapture_options->AudioIn = audio_opt->AudioIn;
	rmcapture_options->AudioInTandem = audio_opt->AudioInTandem;
	rmcapture_options->AudioInAlign = audio_opt->AudioInAlign;
	rmcapture_options->AudioInLSBfirst = audio_opt->AudioInLSBfirst;
	rmcapture_options->OutputChannels = audio_opt->OutputChannels;
	rmcapture_options->OutputLfe = audio_opt->OutputLfe;
	rmcapture_options->SignedPCM = audio_opt->SignedPCM;
	rmcapture_options->auto_detect_codec = audio_opt->auto_detect_codec;
	rmcapture_options->mclk = audio_opt->mclk;
	rmcapture_options->lpcm_24bit = local_opt->lpcm_24bit;
	
	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 rmcapture_instance *pCapture = NULL;
	enum cap_video_input video_input_port = cap_video_input_none;
	enum cap_audio_input audio_input_port = cap_audio_input_none;
	RMuint32 video_input_portnum = 0, audio_input_portnum = 0;
	RMuint32 key_set = SET_KEY_DEBUG | SET_KEY_AUDIO | SET_KEY_DISPLAY;
	RMbool AudioIn;
	
	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, local_opt[0].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 = local_opt[0].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));
	
	// Video output init
	err = apply_display_options(&dcc_info, &disp_opt);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot set display opions! %s\n", RMstatusToString(err));
		goto cleanup;
	}
	
	// Audio output init
	AudioIn = audio_opt.AudioIn;
	audio_opt.AudioIn = FALSE;  // handle audio capture in cap_audio, not in apply_audio
	// apply the sample rate, serial out status
	err = apply_audio_engine_options(&dcc_info, &audio_opt);
	if (RMFAILED(err)) {
		fprintf(stderr, "Error applying audio engine options! %s\n", RMstatusToString(err));
		//goto cleanup;;
	}
	// apply the audio format - uninit, set codec, set specific parameters, init
	err = apply_audio_decoder_options(&dcc_info, &audio_opt);
	if (RMFAILED(err)) {
		fprintf(stderr, "Error applying audio_decoder_options! %s\n", RMstatusToString(err));
		//goto cleanup;
	}
	audio_opt.AudioIn = AudioIn;
	
	transfer_capture_options(&rmcapture_options, &capture_opt[0], &disp_opt, &audio_opt, &local_opt[0]);
	
	// open capture instance
	err = rmcapture_open(dcc_info.pRUA, dcc_info.pDCC, &rmcapture_options, &pCapture);
	if (RMFAILED(err) || (pCapture == NULL)) {
		fprintf(stderr, "Failed to create instance of the capture! %s\n", RMstatusToString(err));
		goto cleanup;
	}
	
	// register callback function
	myapp_capture_context.dcc_info = &dcc_info;
	myapp_capture_context.pCapture = pCapture;
	err = rmcapture_register_callback(pCapture, &myapp_callback_func, &myapp_capture_context);
	
	// initialize all capture chips
	//err = rmcapture_initialize_chips(pCapture, cap_board_sigma844e1dtv8624);
	err = rmcapture_initialize_chips(pCapture, cap_board_sigma904e1dtv8634);
	
	// select and initialize current input port
// TODO convert input number to input descriptor
	/*
	video_input_port = cap_video_input_hdmi;
	video_input_portnum = 2;
	audio_input_port = cap_audio_input_hdmi;
	audio_input_portnum = 1;
	*/

	/*
	video_input_port = cap_video_input_cvbs;
	video_input_portnum = 1;
	audio_input_port = cap_audio_input_stereo;
	audio_input_portnum = 1;
	*/

	video_input_port = cap_video_input_component;
	video_input_portnum = 1;
	audio_input_port = cap_audio_input_stereo;
	audio_input_portnum = 1;

	err = rmcapture_initialize_input(pCapture, 
		video_input_port, video_input_portnum, 
		TRUE, 
		audio_input_port,audio_input_portnum);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to select input: %s\n", RMstatusToString(err));
		err = rmcapture_close(pCapture);		
		goto cleanup;
	}
	
	fprintf(stderr, "RUA Sample Application play_rmcapture\n");
	display_key_usage(key_set);
	
	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, key_set, key);
			if (cmd == RM_QUIT) run = FALSE;
			
			if (0) {  // e.g. if other input is selected
				err = rmcapture_close_input(pCapture);
				if (RMFAILED(err)) {
					fprintf(stderr, "Failed to close input: %s\n", RMstatusToString(err));
				}
				//err = rmcapture_select_input(pCapture, &(VideoInput[1]));
				if (RMFAILED(err)) {
					fprintf(stderr, "Failed to select input: %s\n", RMstatusToString(err));
				}
			}
		}
		
		err = rmcapture_loop(pCapture);
		
		RMMicroSecondSleep(100000);
	}
	
	err = rmcapture_close_input(pCapture);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to close input: %s\n", RMstatusToString(err));
	}
	
	err = rmcapture_close(pCapture);
	pCapture = 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;
}