osdbuf_control.c

Sample code for use on smp 863x processor.

		case '0':
			args = sscanf(optarg,"%ld",&osd->alpha0);
			if ( args != 1){
				printf("Error parsing alpha0\n");
				osdbuf_control_usage(argv[0]);
			}
			CROP(osd->alpha0,255);
			command |= OSD_SET_A0;
			printf("Alpha0 : %ld\n",osd->alpha0);
			break;
		case '1':
			args = sscanf(optarg,"%ld",&osd->alpha1);
			if ( args != 1){
				printf("Error parsing alpha1\n");
				osdbuf_control_usage(argv[0]);
			}
			CROP(osd->alpha1,255);
			command |= OSD_SET_A1;
			printf("Alpha1 : %ld\n",osd->alpha1);
			break;
		case 'a':
			{
				RMuint32 tmp;
				args = sscanf(optarg,"%lu",&tmp);
				if ( args != 1 ){
					printf("Error parsing fading parameter\n");
					osdbuf_control_usage(argv[0]);
				}
				CROP(tmp,1);
				osd->fading = (RMbool) tmp;
				printf("Fading : %s\n", osd->fading ?
				       "enabled" : "disabled");
				command |= OSD_SET_FADING;
			}
			break;
		case 'O':
			{
				RMuint32 tmp;
				args = sscanf(optarg,"%lu",&tmp);
				if ( args != 1 ){
					printf("Error parsing ouput parameter\n");
					osdbuf_control_usage(argv[0]);
				}
				CROP(tmp,1);
				osd->dcc_info.disp_info->osd_enable[0] = (RMbool) tmp;
				printf("OSD Channel : %s\n", osd->dcc_info.disp_info->osd_enable[0] ?
				       "enabled" : "disabled");
				command |= OSD_SET_OUTPUT;
			}
			break;
		case 'C':
			fprintf(stderr,"Warning : -C is deprecated, use -cs instead\n");
			break;
		case 'x':
			command |= OSD_BIND_FB;
			osd->fb = optarg;
			break;
		case 'X':
			command |= OSD_UNBIND_FB;
			osd->fb = optarg;
			break;
		default :
			osdbuf_control_usage(argv[0]);
		}

	/* Check the command line means something */
	if ( ((command & OSD_DEL) && (command & ~(OSD_DEL|OSD_UNBIND_FB))) ||	//no parameters with delete other than unbind
	     ((command & OSD_GET_INFOS) && (command & ~OSD_GET_INFOS)) ||	//idem for get infos
	     ((command & OSD_GET_PARAMS) && (command & ~OSD_GET_PARAMS)) ||	//idem for get params
	     ((command & OSD_SET_FORMAT) && !(command & OSD_CREATE)) )		//set format allowed only if create
		osdbuf_control_usage(argv[0]);

	/* Init other fields */
	osd->bpp = get_osd_bpp(osd->profile.ColorMode, osd->profile.ColorFormat);
}

/**
 * Unbind the given fb_dev
 * @param fb_dev
 * @return < 0 on error
 */
static int unbind_fb(RMascii *fb_dev)
{
	struct mambolfb_config_s config = {0,0,0,0,0,0};
	int fd;
		
	if (fb_dev == NULL)
		return -1;

	fd = open(fb_dev, O_RDONLY);
	if (fd < 0){
		perror("Error opening Mambo/Tango frame buffer");
		return -1;
	}

	if (ioctl(fd, MAMBOLFBIO_SETBUFFER, &config) < 0){
		perror("Error unbinding OSD buffer from frame buffer device");
		return -1;
	}

	fprintf(stderr,"Frame buffer %s unbound\n", fb_dev);
	return 0;
}

int main(int argc, char *argv[])
{
	RMstatus status = RM_OK;
	struct osd_descriptor my_osd, tmp_osd;
	struct display_context disp_info, tmp_disp_info;
	struct dh_context dh_info = {0,};


	
	status = init_display_options(&disp_opt);
	if (RMFAILED(status)){
		printf("Error initializing display options! %d\n", status);
		goto wayout;
	}
	disp_opt.dh_info = &dh_info;
	
	my_osd.dcc_info.disp_info = &disp_info;
	/* Init the descriptor with the command line*/
	parse_cmdline(argc, argv, &my_osd);

	/*  Catch all temination signals, call RMTermInit() and cleanup(), then exit(0). */
	RMSignalInit(cleanup, (void *) &my_osd);

	DEB(fprintf(stderr,"  RUACreateInstance\n"));
	
	status = RUACreateInstance(&my_osd.dcc_info.pRUA, my_osd.chip_num);
	if (RMFAILED(status)){
		printf("Error creating instance! %d\n", status);
		goto wayout;
	}

	DEB(fprintf(stderr,"  DCCOpen\n"));
	status = DCCOpen(my_osd.dcc_info.pRUA, &my_osd.dcc_info.pDCC);
        if (RMFAILED(status)) {
                fprintf(stderr, "Error Opening DCC! %d\n", status);
		goto wayout;
        }

	/* Keep a copy of the initialized osd for command line parameters */
	memcpy(&tmp_osd, &my_osd, sizeof(my_osd));
	tmp_osd.dcc_info.disp_info = &tmp_disp_info;
	memcpy(&tmp_disp_info, &disp_info, sizeof(disp_info));

	if ((command & OSD_BIND_FB) && (command & OSD_CREATE)){
		/* Create a new buffer and binds it. For safety, undbind the FB
		 * dev first in case it is currently used : we don't want the
		 * FB dev to write in a memory that is not an OSD buffer
		 * anymore */
		if (unbind_fb(my_osd.fb) < 0)
			goto wayout_error;
	}

	if (command & OSD_CREATE){
		struct osd_descriptor current_osd;

		memcpy(&current_osd, &my_osd, sizeof(my_osd));
		if (RMFAILED(get_osd_infos(&current_osd))){
			fprintf(stderr,"Error getting OSD buffer parameters.\n");
			goto wayout_error;
		}

		/* If there is already an OSD buffer registered, delete it */
		if (current_osd.LumaSize || current_osd.ChromaSize){
			RMuint32 surface=0;
			RUASP(current_osd.dcc_info.pRUA, current_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_Surface,
				(void *) &surface, sizeof(surface));
		}
		
		DEB(fprintf(stderr,"Creating new buffer\n"));
		
		status = DCCInitChainEx(my_osd.dcc_info.pDCC, disp_opt.init_mode);
		if (RMFAILED(status)) {
			fprintf(stderr, "Cannot initialize microcode %d\n", status);
			goto wayout;
		} 
		
		my_osd.dcc_info.SurfaceID = my_osd.dcc_info.disp_info->osd_scaler[0];
		DEB(fprintf(stderr,"  set_default_out_window\n"));
		set_default_out_window(&(my_osd.dcc_info.disp_info->osd_window[0]));
		my_osd.dcc_info.disp_info->active_window = &(my_osd.dcc_info.disp_info->osd_window[0]);

		status = apply_display_options(&my_osd.dcc_info, &disp_opt);
		if (RMFAILED(status)) {
			fprintf(stderr, "Cannot set display opions %s\n", RMstatusToString(status));
			goto wayout;
		}

		status = create_osd_buf(&my_osd);
		if(RMFAILED(status)){
			fprintf(stderr,"Error creating OSD : %d\n", status);
			goto wayout;
		}
	
		status = DCCGetOSDVideoSourceInfo(my_osd.dcc_info.pOSDSource[0], &my_osd.LumaAddr, &my_osd.LumaSize,
						  &my_osd.ChromaAddr, &my_osd.ChromaSize);
		if (RMFAILED(status)){
			fprintf(stderr,"Error getting OSD source infos\n");
			goto wayout;
		}

		status = DCCEnableVideoSource(my_osd.dcc_info.pOSDSource[0], TRUE);
		if (RMFAILED(status)){
			fprintf(stderr,"Error enabling OSD buffer : %d\n",status);
			goto wayout;
		}
		
		print_osd_info(&my_osd);
	}

	if ( command & OSD_BIND_FB ){
		struct mambolfb_config_s config;
		int fd;
		
		if (RMFAILED(get_osd_infos(&my_osd))){
			fprintf(stderr,"Error getting OSD buffer parameters.\n");
			goto wayout_error;
		}

		if (my_osd.ChromaSize == 0 && my_osd.LumaSize == 0){
			fprintf(stdout,"No persistent OSD buffer registered\n");
			goto wayout_error;
		} else {
			if (my_osd.LumaSize){
				config.videomemory = my_osd.LumaAddr;
				config.videomemorysize = my_osd.LumaSize;
			}else {
				config.videomemory = my_osd.ChromaAddr;
				config.videomemorysize = my_osd.ChromaSize;
			}
			config.palette = BASE_PALETTE;
			config.xres = my_osd.profile.Width;
			config.yres = my_osd.profile.Height;
			config.bits_per_pixel = my_osd.bpp;
		}

		fd = open(my_osd.fb, O_RDONLY);
		if (fd < 0){
			perror("Error opening Mambo/Tango frame buffer");
			goto wayout_error;
		}

		if (ioctl(fd, MAMBOLFBIO_SETBUFFER, &config) < 0){
			perror("Error binding OSD buffer to frame buffer device");
			goto wayout_error;
		}

		fprintf(stderr,"OSD buffer bound to %s.\n",my_osd.fb);
	}

	if ( command & OSD_SET_A0 ){
		DEB(fprintf(stderr,"Alpha0 = %ld\n", tmp_osd.alpha0));
		OSDGET_RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_Alpha0,
		             (void *) &tmp_osd.alpha0, sizeof(tmp_osd.alpha0));
	}

	if ( command & OSD_SET_A1 ){
		DEB(fprintf(stderr,"Alpha1 = %ld\n", tmp_osd.alpha1));
		OSDGET_RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_Alpha1,
		             (void *) &tmp_osd.alpha1, sizeof(tmp_osd.alpha1));
	}
		
	if ( command & OSD_SET_FADING )
		OSDGET_RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_EnableFading,
		             (void *) &tmp_osd.fading, sizeof(tmp_osd.fading));

	if ( command & OSD_SET_OUTPUT )
		OSDGET_RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_Enable,
		             (void *) &tmp_osd.dcc_info.disp_info->osd_enable[0], sizeof(tmp_osd.dcc_info.disp_info->osd_enable[0]));

	if ( command & ( OSD_SET_ADAPT | OSD_SET_ANTIF | OSD_SET_TAPS )) {
		get_osd_infos(&my_osd);
		if ( command & OSD_SET_ADAPT )
			my_osd.scaling_config.AdaptativeEnable = tmp_osd.scaling_config.AdaptativeEnable;
		if ( command & OSD_SET_ANTIF ){
			my_osd.scaling_config.AntiFlickerColor = tmp_osd.scaling_config.AntiFlickerColor;
			my_osd.scaling_config.AntiFlickerAlpha = tmp_osd.scaling_config.AntiFlickerAlpha;
		}
		if ( command & OSD_SET_TAPS )
			my_osd.scaling_config.Taps = tmp_osd.scaling_config.Taps;
		RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMDispOSDScalerPropertyID_ScalingConfig,
		      &my_osd.scaling_config, sizeof(my_osd.scaling_config));
	}

	if ( command & OSD_SET_KCOLOR ){
		get_osd_infos(&my_osd);
		memcpy((void *)&my_osd.kcolor,(void *)&tmp_osd.kcolor, sizeof(my_osd.kcolor));
		RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_KeyColor,
		      &my_osd.kcolor, sizeof(my_osd.kcolor));
	}

	if ( command & OSD_SET_CSC )
		/* FIXME get the mixer from DCC */
		OSDGET_RUASP(my_osd.dcc_info.pRUA, EMHWLIB_MODULE(DispMainMixer,0), RMGenericPropertyID_ColorSpace,
		             (void *) &tmp_osd.profile.ColorSpace, sizeof(tmp_osd.profile.ColorSpace));

	if ( command & OSD_UNBIND_FB ){
		if (unbind_fb(my_osd.fb) <0)
			goto wayout_error;
	}

	if ( command & OSD_DEL ){
		RMuint32 surface=0;
		OSDGET_RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_Surface,
		             (void *) &surface, sizeof(surface));
		fprintf(stderr,"OSD buffer deleted.\n");
	}


	if( command & OSD_GET_INFOS ){
		if (RMFAILED(get_osd_infos(&my_osd)))
			my_osd.LumaAddr = 0;
		printf("===================== Buffer Infos ======================\n");
		print_osd_full_info(&my_osd);
		printf("=========================================================\n");
	}

	if ( command & OSD_GET_PARAMS ){
		get_osd_infos(&my_osd);
		print_osd_info(&my_osd);
	}

	/* Last but not least, validate changes */
	if ( command & ( OSD_SET_KCOLOR | OSD_SET_ADAPT | OSD_SET_TAPS | OSD_SET_ANTIF | 
			 OSD_SET_A0 | OSD_SET_A1 | OSD_SET_FADING | OSD_SET_OUTPUT) ){
		RMuint32 validate=0;
		RUASP(my_osd.dcc_info.pRUA, my_osd.dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_Validate,
		      (void *)&validate, sizeof(validate));
	}

	if ( command & OSD_SET_CSC ){
		RMuint32 validate=0;
		RUASP(my_osd.dcc_info.pRUA, EMHWLIB_MODULE(DispMainMixer,0), RMGenericPropertyID_Validate,
		      (void *)&validate, sizeof(validate));
	}
	
 wayout:
	cleanup((void *)&my_osd);
	DEB(fprintf(stderr,"end main\n"));
	if (RMFAILED(status))
		return EXIT_FAILURE;
	return EXIT_SUCCESS;
	
 wayout_error:
	status = RM_ERROR;
	goto wayout;

	return EXIT_SUCCESS;
}