parse_video_cmdline.c

Sample code for use on smp 863x processor.

				return err;
			}

			err = DCCEnableVideoSource(dcc_info->pCCOSDSource, TRUE);
			if (RMFAILED(err)){
				RMDBGLOG((ENABLE, "Error enabling OSD buffer : %d\n",err));
				return err;
			}
			
			err = RUAExchangeProperty(dcc_info->pRUA, mixer, RMGenericPropertyID_MixerSourceIndex, &scaler, sizeof(scaler), &src_index, sizeof(src_index));
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot get scaler index\n"));
				return err;
			}
			
			/* display the osd only on the active region of the screen (80% width, 80% height) */
				
			mixer = EMHWLIB_TARGET_MODULE(mixer, 0, src_index);

			window.Width = 8*4096/10;
			window.Height = 8*4096/10;
			while ((err = RUASetProperty(dcc_info->pRUA, mixer, RMGenericPropertyID_MixerSourceWindow, &(window), sizeof(window), 0)) == RM_PENDING);
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot set scaler output window %d\n", err));
				return err;
			}

			if(options->use_soft_cc_decoder == 2){
 
				/* this asks the video decoder to put only the eia708 closed caption
				 * data into the fifo. The default is to put only eia608 so we don't need
				 * to handle this when use_soft_cc_decoder == 1
				 */
				struct CCFifo_AllowedTypes_type allowed_types;
				allowed_types.Allow608 = FALSE;
				allowed_types.Allow708 = TRUE;
				err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_AllowedTypes, &(allowed_types), sizeof(allowed_types), 0);
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Cannot set scaler input window on OSD surface %d\n", err));
					return err;
				}
				/* make this instance of rmscc a eia708 decoder */
				scc_init.format = rmscc_eia_708;
			}
			else if (options->use_soft_cc_decoder == 1){
				/* make this instance of rmscc a eia608 decoder */
				scc_init.format = rmscc_eia_608;
			}
			else{
				RMDBGLOG((ENABLE, "Wrong value for use_soft_decoder\n"));
				return RM_ERROR;
			}
			rtk_handle.pOSDSource = dcc_info->pCCOSDSource;
			rtk_handle.pRUA = dcc_info->pRUA;
		
			scc_init.rtk = RMFRTKOpen(&rtk_handle);
			if(scc_init.rtk == NULL){
				RMDBGLOG((ENABLE, "Error opening rtk: %d\n",err));
				return RM_ERROR;
			}
				
			scc_init.resize_callback = NULL;
			scc_init.cc_select = (enum rmscc_ccselect)((RMuint32)options->cc_select - 1);
			dcc_info->scc = RMSCCOpen(&scc_init);
			if(dcc_info->scc == NULL){
				RMDBGLOG((ENABLE, "Error opening scc: %d\n",err));
				return RM_ERROR;
			}
			
			dcc_info->rtk= scc_init.rtk;

			/* ask rmscc which palette needs to be set... */
			err = RMSCCGetPalette(dcc_info->scc, &cc_palette, &used_colors);
			if (RMFAILED(err)){
				RMDBGLOG((ENABLE, "Error enabling OSD buffer : %d\n",err));
				return err;
			}

			/* and set it */
			while ((err = RUASetProperty(dcc_info->pRUA, scaler, RMGenericPropertyID_8BPP_LUT, &cc_palette, sizeof(cc_palette), 0)) == RM_PENDING);
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot set LUT for OSD scaler: %s\n", RMstatusToString(err)));
				return err;
			}

			while ((err = RUASetProperty(dcc_info->pRUA, scaler, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot validate scaler input window: %s\n", RMstatusToString(err)));
				return err;
			}

			
			/* rmscc has cleared the osd so now we can displayed it */
			enable = TRUE;
			err =  RUASetProperty(dcc_info->pRUA, scaler, RMGenericPropertyID_Enable, &enable, sizeof(enable), 0);
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot enable scaler\n"));
				return err;
			}
				
		}
		else{
			while ((err = RUASetProperty(dcc_info->pRUA, mixer, RMGenericPropertyID_CCFifo, &dcc_info->ccfifo_out_id, sizeof(dcc_info->ccfifo_out_id), 0)) == RM_PENDING);
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot set CC_fifo\n"));
				return err;
			}
		}
		
		while ((err = RUASetProperty(dcc_info->pRUA, mixer, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot validate mixer settings\n"));
			return err;
		}
		
		err = RUASetProperty(dcc_info->pRUA, dcc_info->video_decoder, RMGenericPropertyID_CCFifo, &dcc_info->ccfifo_in_id, sizeof(dcc_info->ccfifo_in_id), 0);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot set CC_fifo on video decoder\n"));
			return err;
		}
	}
	else {
		dcc_info->ccfifo_in_id = 0;
		dcc_info->ccfifo_out_id = 0;
	}
	if (options->display_ttx) {
		RMuint32 mixer;
		mixer = EMHWLIB_MODULE(DispMainMixer, 0);
		dcc_info->ttx_fifo_id = EMHWLIB_MODULE(TTXFifo, 0); // use one ttx fifo for now
		if( dcc_info->ttx_sw_decoder == 0 )  // make sure the TTXfifo is opened
			dcc_info->ttx_sw_decoder = RMTTXOpen( dcc_info->pRUA, dcc_info->ttx_fifo_id, TTX_FIFO_SIZE );

		while ((err = RUASetProperty(dcc_info->pRUA, mixer, RMGenericPropertyID_TTXFifo, &(dcc_info->ttx_fifo_id), sizeof(RMuint32), 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot set TTX_fifo\n"));
			return err;
		}
	}
	return RM_OK;
}

RMstatus clear_video_options(struct dcc_context *dcc_info, struct video_cmdline *options)
{
	RMstatus err;
	struct RUAEvent evt;
	RMuint32 wait_count;
	RMbool cc_done = FALSE;
	RMbool mute = TRUE;



	err = RM_OK;
	evt.ModuleID = DisplayBlock;
	evt.Mask = EMHWLIB_DISPLAY_EVENT_ID(DispMainMixer);

	if (dcc_info->ccfifo_in_id) {
		if (options->use_soft_cc_decoder) {
			RMDBGLOG((DEBUG, "Closing soft CC decoder...\n"));
			RMFRTKClose(dcc_info->rtk);
			
			err = DCCCloseVideoSource(dcc_info->pCCOSDSource);
			if (RMFAILED(err)) 
			{
				RMDBGLOG((ENABLE, "Cannot close cc-osd source %s\n", RMstatusToString(err)));
				return err;
			}
			dcc_info->pCCOSDSource = NULL;
			RMDBGLOG((DEBUG, "Done closing soft CC decoder.\n"));
			RMSCCClose(dcc_info->scc);
		}
		else{
			wait_count = 0;
			while((err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_Mute, &mute, sizeof(mute), 0) == RM_PENDING) && (wait_count <4)){
				RUAWaitForMultipleEvents(dcc_info->pRUA, &evt, 1, 500000, NULL);
				wait_count++;
			}

			wait_count = 0;
			while((err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_Flush, NULL, 0, 0) == RM_PENDING) && (wait_count <4)){
				RUAWaitForMultipleEvents(dcc_info->pRUA, &evt, 1, 500000, NULL);
				wait_count++;
			}

			wait_count = 0;
			while((err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_Clear, NULL, 0, 0) == RM_PENDING) && (wait_count <4)){
				RUAWaitForMultipleEvents(dcc_info->pRUA, &evt, 1, 500000, NULL);
				wait_count++;
			}
		}

		/* the clear and flush commands can take some vsyncs to execute (flush(1), clear(4)) 
		   here we wait until they are finished before closing the CCFifo
		*/
		wait_count = 0;
		do{
			err = RUAGetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_FifoEmpty, &cc_done, sizeof(cc_done));
			if(!cc_done){
				RUAWaitForMultipleEvents(dcc_info->pRUA, &evt, 1, 500000, NULL);
				wait_count++;
			}
		}while((!cc_done) && wait_count<16);
		if(!cc_done)
			RMDBGLOG((ENABLE, "ERROR CLEARING CCFIFO!\n"));

		while( (err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_Close, NULL, 0, 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			fprintf(stderr, "Cannot close ccfifo %s\n", RMstatusToString(err));
		}
	}

	if ((dcc_info->ccfifo_out_id) && (dcc_info->ccfifo_out_id != dcc_info->ccfifo_in_id)) {
		RMDBGLOG((DEBUG, "Clearing CC fifo #%lu...\n", EMHWLIB_MODULE_INDEX(dcc_info->ccfifo_out_id)));
		err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_out_id,
				     RMCCFifoPropertyID_Clear, NULL, 0, 0);
		if (RMFAILED(err)) {
			fprintf(stderr, "Cannot clear passthrough CCfifo %s\n", RMstatusToString(err));
		}
		RMDBGLOG((DEBUG, "Done clearing CC fifo.\n"));

		RMDBGLOG((DEBUG, "Closing CC passthrough fifo #%lu...\n", EMHWLIB_MODULE_INDEX(dcc_info->ccfifo_out_id)));
		while( (err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_out_id, 
					     RMCCFifoPropertyID_Close, NULL, 0, 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			fprintf(stderr, "Cannot close passthrough ccfifo %s\n", RMstatusToString(err));
		}
		RMDBGLOG((DEBUG, "Done closing CC passthrough fifo.\n"));
	}
	
	if (dcc_info->ccfifo_in_addr) {
		DCCFree(dcc_info->pDCC, dcc_info->ccfifo_in_addr);
		RMDBGLOG((DEBUG, "Done freeing CC fifo memory.\n"));
	}
	
	if (dcc_info->ccfifo_out_addr) {
		DCCFree(dcc_info->pDCC, dcc_info->ccfifo_out_addr);
		RMDBGLOG((DEBUG, "Done freeing CC passthrough fifo memory.\n"));
	}
	
	if (options->display_ttx) {  // close ttx in case of program change 
		if( dcc_info->ttx_sw_decoder != 0 ) { 
			RMTTXClose( dcc_info->ttx_sw_decoder );
			dcc_info->ttx_sw_decoder = 0;
		}
	}
	return RM_OK;
}


RMstatus refresh_soft_cc(struct dcc_context *dcc_info)
{    
	RMstatus err;
	struct CCFifo_CCEntry_type cc_entry;
	enum rmscc_ccselect ccselect = RMSCCGetDisplayCCType(dcc_info->scc);
	
	while (RMSUCCEEDED(RUAGetProperty(dcc_info->pRUA, dcc_info->ccfifo_in_id, RMCCFifoPropertyID_CCEntry, &cc_entry, sizeof(cc_entry)))) {
		if (RMFAILED(err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_out_id, RMCCFifoPropertyID_CCEntry, &cc_entry, sizeof(cc_entry), 0))) {
			RMDBGLOG((DEBUG, "Failed to pass through CC entry! %s\n", RMstatusToString(err)));
			if (err == RM_PENDING) { // probably a STC discontinuity, flush old CC data
				RMuint64 usec;
				RMDBGLOG((DEBUG, "Flushing and clearing CC fifo #%lu...\n", 
					EMHWLIB_MODULE_INDEX(dcc_info->ccfifo_out_id)));
				usec = get_ustime();
				while (RMFAILED(err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_out_id, 
					RMCCFifoPropertyID_Flush, NULL, 0, 0)) && (get_ustime() - usec < 20000));
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Cannot flush CCfifo %s\n", RMstatusToString(err)));
				}
				usec = get_ustime();
				while (RMFAILED(err = RUASetProperty(dcc_info->pRUA, dcc_info->ccfifo_out_id, 
					RMCCFifoPropertyID_Clear, NULL, 0, 0)) && (get_ustime() - usec < 20000));
				if (RMFAILED(err)) {
					RMDBGLOG((ENABLE, "Cannot clear CCfifo %s\n", RMstatusToString(err)));
				}
				RMDBGLOG((DEBUG, "Done flushing and clearing CC fifo.\n"));
			}
		}
		if (cc_entry.Enable){
			switch(cc_entry.Type){
			case EMhwlibCCType_TopField:
			case EMhwlibCCType_BottomField:
				if( (ccselect != rmscc_not_available) && (((RMuint32)ccselect & 0x2)>>1 == cc_entry.Type) ) {
					if(ccsize >= 128 - 2){
						RMSCCDecode(dcc_info->scc, ccbuf, ccsize, get_ustime() );
						ccsize = 0;
					}
					ccbuf[ccsize++] = cc_entry.CC1;
					ccbuf[ccsize++] = cc_entry.CC2;
				}
				break;
			case EMhwlibCCType_DTVCCHeader:
				if(dtvsize){
					RMSCCDecode(dcc_info->scc, dtvbuf, dtvsize, get_ustime() );
					dtvsize = 0;
				}
			case EMhwlibCCType_DTVCCData:
				if (dtvsize < 128 - 1) {
					dtvbuf[dtvsize++] = cc_entry.CC1;
					dtvbuf[dtvsize++] = cc_entry.CC2;
				}
				break;
			default:
				break;
			}
		}
	}
	if(ccsize){
		RMSCCDecode(dcc_info->scc, ccbuf, ccsize, get_ustime() );
		ccsize = 0;
	}
	if(dtvsize >= 128){
		fprintf(stderr, "More than 127 dtv bytes without a header?\n");
		return RM_ERROR;
	}
     
	return RM_OK;
}

RMstatus video_profile_to_codec(enum MPEG_Profile profile, enum EMhwlibVideoCodec *pvcodec,
	RMuint32 *pprofile, RMuint32 *plevel, RMuint32 *pextra_buffers,
	RMuint32 *pwidth, RMuint32 *pheight)
{
	/* set codec based on command line option */
	*pextra_buffers = 0;
	*pprofile = 0;
	*plevel = 0;
	
	switch(profile) {
	case Profile_MPEG2_SD:
	case Profile_MPEG2_DVD:
	case Profile_MPEG2_SD_DeInt:
	case Profile_MPEG2_DVD_DeInt:
		*pvcodec = EMhwlibVideoCodec_MPEG2;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_MPEG2_HD:
	case Profile_MPEG2_HD_DeInt:
		*pvcodec = EMhwlibVideoCodec_MPEG2;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	case Profile_MPEG4_SD:
	case Profile_MPEG4_SD_DeInt:
		*pvcodec = EMhwlibVideoCodec_MPEG4;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_MPEG4_SD_Padding:
	case Profile_MPEG4_SD_DeInt_Padding:
		*pvcodec = EMhwlibVideoCodec_MPEG4_Padding;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_MPEG4_HD:
	case Profile_MPEG4_HD_DeInt:
		*pvcodec = EMhwlibVideoCodec_MPEG4;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	case Profile_MPEG4_HD_Padding:
	case Profile_MPEG4_HD_DeInt_Padding:
		*pvcodec = EMhwlibVideoCodec_MPEG4_Padding;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	case Profile_DIVX3_SD:
		*pvcodec = EMhwlibVideoCodec_DIVX3;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_DIVX3_HD:
		*pvcodec = EMhwlibVideoCodec_DIVX3;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	case Profile_VC1_SD:
		*pvcodec = EMhwlibVideoCodec_VC1;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_VC1_HD:
		*pvcodec = EMhwlibVideoCodec_VC1;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	case Profile_WMV_SD:
		*pvcodec = EMhwlibVideoCodec_WMV;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_WMV_816P:
		*pvcodec = EMhwlibVideoCodec_WMV;
		*pwidth = 1440;
		*pheight = 816;
		break;
	case Profile_WMV_HD:
		*pvcodec = EMhwlibVideoCodec_WMV;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	case Profile_H264_SD:
	case Profile_H264_SD_DeInt:
		*pvcodec = EMhwlibVideoCodec_H264;
		*pprofile = EMhwlib_H264_BaselineProfile;
		*plevel = EMhwlib_H264_Level_4;
		*pwidth = 720;
		*pheight = 576;
		break;
	case Profile_H264_HD:
	case Profile_H264_HD_DeInt:
		*pvcodec = EMhwlibVideoCodec_H264;
		*pprofile = EMhwlib_H264_BaselineProfile;
		*plevel = EMhwlib_H264_Level_4;
		*pwidth = 1920;
		*pheight = 1080;
		break;
	default:
		RMDBGLOG((ENABLE, "Unknown video decoder codec \n"));
		return RM_ERROR;
	}
	return RM_OK;
}