play_capture.c

Sample code for use on smp 863x processor.

			argi++;
			if (argi < argc) {
				switch (argv[argi][0]) {
					default:
					case 'n':  // NTSC WSS "4:3 frame"
					case 'N':
						options->force_active_format = TRUE;
						options->active_format = EMhwlibAF_same_as_picture;
						options->force_wide_screen = TRUE;
						options->wide_screen = FALSE;
						break;
					case 'w':  // NTSC WSS "16:9 frame"
					case 'W':
						options->force_active_format = TRUE;
						options->active_format = EMhwlibAF_same_as_picture;
						options->force_wide_screen = TRUE;
						options->wide_screen = TRUE;
						break;
					case 'l':  // NTSC WSS "16:9 in 4:3 frame"
					case 'L':
						options->force_active_format = TRUE;
						options->active_format = EMhwlibAF_16x9_centered;
						options->force_wide_screen = TRUE;
						options->wide_screen = FALSE;
						break;
				}
			} else {
				fprintf(stderr, "please specify a mode (normal, wide or letterbox) after %s\n", argv[argi - 1]);
				err = RM_ERROR;
			}
		}
		else if (! strcmp(&(argv[argi][1]), "window")) {
			SCANPARAM(options->output_window->X, "please specify a x value", 1);
			SCANPARAM(options->output_window->Y, "please specify a y value", 2);
			SCANPARAM(options->output_window->Width, "please specify a w value", 3);
			SCANPARAM(options->output_window->Height, "please specify a h value", 4);
			options->output_window->XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
			options->output_window->YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
			options->output_window->XMode = EMhwlibDisplayWindowValueMode_Fixed;
			options->output_window->YMode = EMhwlibDisplayWindowValueMode_Fixed;
			options->output_window->WidthMode = EMhwlibDisplayWindowValueMode_Fixed;
			options->output_window->HeightMode = EMhwlibDisplayWindowValueMode_Fixed;
		}
		else if (! strcmp(&(argv[argi][1]), "ov")) {
			SCANPARAM(options->overscan_crop_amount, "please specify a percentage for overscan crop", 1);
			if (options->overscan_crop_amount >= 100) options->overscan_crop_amount = 99;
		}
		else if (! strcmp(&(argv[argi][1]), "vbidump")) {
			argi++;
			if (argi < argc) {
				options->arg_vbi = argi;
			} else {
				fprintf(stderr, "please specify a file name after %s\n", argv[argi - 1]);
				err = RM_ERROR;
			}
		}
		else if (! strcmp(&(argv[argi][1]), "vbiprint")) {
			options->dump_vbi = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "anc")) {
			options->parse_anc = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "ancprint")) {
			options->parse_anc = TRUE;
			options->print_anc = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "m")) {
			SCANPARAM(chip_num, "please specify a chip number", 1);
		}
		else if (! strcmp(&(argv[argi][1]), "i2ccc")) {
			if ((argi + 1 >= argc) || (argv[argi + 1][0] == '-')) {
				options->enable_i2c_cc = TRUE;  // only for SAA 7119
			} else {
				if (! strcmp(argv[argi + 1], "7119")) {
					options->i2c_cc.APIVersion = 1;
					options->i2c_cc.Enable = TRUE;
					options->i2c_cc.Speed = 100;   // I2C speed in kHz
					options->i2c_cc.Delay = 10;   // I2C delay in uSec
					options->i2c_cc.WriteDevice = 0x00;  // disable init write
					options->i2c_cc.WriteSubAddr = 0x00;
					options->i2c_cc.WriteData = 0x00;
					options->i2c_cc.ReadDevice = 0x40;   // I2C device address
					options->i2c_cc.ReadSubAddr = 0x66;  // I2C sub address
					options->i2c_cc.ReadSize = 5;    // data size (up to 32 bytes)
					options->i2c_cc.OddStatusOffs = 0;    // Odd field: CC valid = (data[OddStatusOffs] & OddStatusMask == OddStatusExpect)
					options->i2c_cc.OddStatusMask = 0xC0;
					options->i2c_cc.OddStatusExpect = 0x00;
					options->i2c_cc.OddByte1Offs = 1;    // offset in data for CC byte 1.
					options->i2c_cc.OddByte2Offs = 2;    // offset in data for CC byte 2.
					options->i2c_cc.EvenStatusOffs = 0;  // Even field: CC valid = (data[EvenStatusOffs] & EvenStatusMask == EvenStatusExpect)
					options->i2c_cc.EvenStatusMask = 0x30;
					options->i2c_cc.EvenStatusExpect = 0x00;
					options->i2c_cc.EvenByte1Offs = 3;   // offset in data for CC byte 1.
					options->i2c_cc.EvenByte2Offs = 4;   // offset in data for CC byte 2.
				} else {
					fprintf(stderr, "Unknown capture chip: %s\n", argv[argi + 1]);
					err = RM_ERROR;
				}
				argi++;
			}
		}
		else if (! strcmp(&(argv[argi][1]), "i2cwss")) {
			options->enable_i2c_wss = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "ccprint")) {
			options->ccfifo_print = TRUE;
		}
		else if (! strcmp(&(argv[argi][1]), "softcc")) {
			options->use_soft_cc_decoder = 1;
		}
		else if (! strcmp(&(argv[argi][1]), "softcc608")) {
			options->use_soft_cc_decoder = 1;
		}
		else if (! strcmp(&(argv[argi][1]), "softcc708")) {
			options->use_soft_cc_decoder = 2;
		}
		else if (! strcmp(&(argv[argi][1]), "i2c")) {
			SCANPARAM(options->i2c_module, "please specify a i2c module number", 1);
		}
		else if (! strcmp(&(argv[argi][1]), "I")) {
			options->i2c_init = TRUE;
			options->i2c_board = cap_sigma775avinput;
			options->i2c_port = cap_CVBS1;
			options->i2c_video_chip = cap_SAA7119;
			options->i2c_video_dev = 0x20;
			options->i2c_video_delay = 0;
			options->i2c_audio1_chip = cap_WM8775;
			options->i2c_audio1_dev = 0x1A;
			options->i2c_audio1_delay = 0;
			options->i2c_audio2_chip = cap_NoChip;
			options->i2c_audio2_dev = 0x00;
			options->i2c_audio2_delay = 0;
			if (argi + 1 >= argc) goto SKIP;
			if (argv[argi + 1][0] == '-') goto SKIP;
			argi++;
			if (! strcmp(argv[argi], "775")) {
				options->i2c_board = cap_sigma775avinput;
			} else if (! strcmp(argv[argi], "760e2")) {
				options->i2c_board = cap_sigma760e2hdlcd;
				options->i2c_audio2_chip = cap_MSP34x5;
				options->i2c_audio2_dev = 0x44;
				options->i2c_audio2_delay = 0;
			} else if (! strcmp(argv[argi], "760e1")) {
				options->i2c_board = cap_sigma760e1hdref;
				options->i2c_video_chip = cap_ADV7402;
				options->i2c_video_dev = 0x21;
				options->i2c_audio1_chip = cap_MSP34x5;
				options->i2c_audio1_dev = 0x44;
			} else if (! strcmp(argv[argi], "844e1")) {
				options->i2c_board = cap_sigma844e1dtv;
				options->i2c_audio2_chip = cap_MSP34x5;
				options->i2c_audio2_dev = 0x44;
			} else if (! strcmp(argv[argi], "809e1")) {
				options->i2c_board = cap_pioneer809e1video;
				options->i2c_audio1_chip = cap_NoChip;
				options->i2c_audio1_dev = 0x00;
			} else if (! strcmp(argv[argi], "jamo")) {
				options->i2c_board = cap_kissjamoplasma;
				options->i2c_audio1_chip = cap_MSP34x5;
				options->i2c_audio1_dev = 0x40;
			} else {
				fprintf(stderr, "unknown capture board: %s\n", argv[argi]);
				err = RM_ERROR;
				goto SKIP;
			}
			if (argi + 1 >= argc) goto SKIP;
			if (argv[argi + 1][0] == '-') goto SKIP;
			argi++;
			if (! strcmp(argv[argi], "direct")) {
				options->i2c_port = cap_Direct;
			} else if (! strcmp(argv[argi], "cvbs1")) {
				options->i2c_port = cap_CVBS1;
			} else if (! strcmp(argv[argi], "cvbs2")) {
				options->i2c_port = cap_CVBS2;
			} else if (! strcmp(argv[argi], "svideo1")) {
				options->i2c_port = cap_SVideo1;
			} else if (! strcmp(argv[argi], "svideo2")) {
				options->i2c_port = cap_SVideo2;
			} else if (! strcmp(argv[argi], "vga")) {
				options->i2c_port = cap_VGA;
			} else if (! strcmp(argv[argi], "yuv1")) {
				options->i2c_port = cap_Component1;
			} else if (! strcmp(argv[argi], "yuv2")) {
				options->i2c_port = cap_Component2;
			} else if (! strcmp(argv[argi], "scart1")) {
				options->i2c_port = cap_ScartCVBS1;
			} else if (! strcmp(argv[argi], "scart2")) {
				options->i2c_port = cap_ScartCVBS2;
			} else if (! strcmp(argv[argi], "tuner1")) {
				options->i2c_port = cap_Tuner1;
			} else if (! strcmp(argv[argi], "tuner2")) {
				options->i2c_port = cap_Tuner2;
			} else if (! strcmp(argv[argi], "hdmi0")) {
				options->i2c_port = cap_HDMI0;
			} else if (! strcmp(argv[argi], "hdmi1")) {
				options->i2c_port = cap_HDMI1;
			} else {
				fprintf(stderr, "unknown capture port: %s\n", argv[argi]);
				err = RM_ERROR;
				goto SKIP;
			}
			if (argi + 1 >= argc) goto SKIP;
			if (argv[argi + 1][0] == '-') goto SKIP;
			SCANPARAM(options->i2c_video_dev, "please specify a video i2c device address", 1);
			options->i2c_video_dev >>= 1;
			if (err == RM_ERROR) goto SKIP;
			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 RMstatus read_i2c_data(
	struct RUA *pInstance, 
	RMuint8 delay, 
	RMuint32 dev, 
	RMuint32 addr, 
	RMuint8 *data, 
	RMuint32 data_size)
{
	RMstatus err;
	struct EMhwlibI2CDeviceParameter i2c;
	struct I2C_QueryData_in_type i2c_param; 
	struct I2C_QueryData_out_type i2c_res;
	
	i2c.APIVersion = 1;
	i2c.Clock = GPIOId_Sys_0;
	i2c.Data = GPIOId_Sys_1;
	i2c.Delay = delay;
	i2c.Speed = 100;
	i2c.DevAddr = dev << 1;
	err = RUASetProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_DeviceParameter, &i2c, sizeof(i2c), 0);
	i2c_param.UseSubAddr = TRUE;
	i2c_param.SubAddr = addr;
	i2c_param.DataSize = data_size;
	err = RUAExchangeProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_QueryData, 
		&i2c_param, sizeof(i2c_param), 
		&i2c_res, sizeof(i2c_res));
	if (RMFAILED(err)) {
		RMDBGLOG((LOCALDBG, "Error setting RMI2CPropertyID_QueryData(0x%02X:0x%02X, 0x%02X) on I2C 0x%08lX GPIO %lu/%lu! %s\n", 
			i2c.DevAddr, i2c_param.SubAddr, i2c_param.DataSize, 
			I2C_ModuleID, i2c.Clock, i2c.Data, 
			RMstatusToString(err)));
	}
	RMMemcpy(data, i2c_res.Data, data_size);
	return err;
}

static RMstatus read_i2c(
	struct RUA *pInstance, 
	RMuint8 delay, 
	RMuint32 dev, 
	RMuint32 addr, 
	RMuint32 *data)
{
	RMstatus err;
	struct EMhwlibI2CDeviceParameter i2c;
	struct I2C_QueryRMuint8_in_type i2c_param;
	struct I2C_QueryRMuint8_out_type i2c_res;
	
	i2c.APIVersion = 1;
	i2c.Clock = GPIOId_Sys_0;
	i2c.Data = GPIOId_Sys_1;
	i2c.Delay = delay;
	i2c.Speed = 100;
	i2c.DevAddr = dev << 1;
	err = RUASetProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_DeviceParameter, &i2c, sizeof(i2c), 0);
	i2c_param.SubAddr = addr;
	err = RUAExchangeProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_QueryRMuint8, 
		&i2c_param, sizeof(i2c_param), 
		&i2c_res, sizeof(i2c_res));
//	if (RMSUCCEEDED(err)) RMDBGPRINT((ENABLE, "Reading 0x%02X from i2c 0x%02X:0x%02X\n", i2c_res.Data, i2c.DevAddr | 0x01, addr));
//	else RMDBGPRINT((ENABLE, "Failed to read from i2c 0x%02X:0x%02X\n", i2c.DevAddr | 0x01, addr));
	*data = i2c_res.Data;
	return err;
}

static RMstatus write_i2c(
	struct RUA *pInstance, 
	RMuint8 delay, 
	RMuint32 dev, 
	RMuint32 addr, 
	RMuint32 data)
{
	RMstatus err;
	struct EMhwlibI2CDeviceParameter i2c;
	struct I2C_WriteRMuint8_type i2c_write;
	
	i2c.APIVersion = 1;
	i2c.Clock = GPIOId_Sys_0;
	i2c.Data = GPIOId_Sys_1;
	i2c.Delay = delay;
	i2c.Speed = 100;
	i2c.DevAddr = dev << 1;
	err = RUASetProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_DeviceParameter, &i2c, sizeof(i2c), 0);
	i2c_write.SubAddr = addr;
	i2c_write.Data = data;
	err = RUASetProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_WriteRMuint8, &i2c_write, sizeof(i2c_write), 0);
//	if (RMSUCCEEDED(err)) RMDBGPRINT((ENABLE, "Wrote 0x%02X to i2c 0x%02X:0x%02X\n", data, i2c.DevAddr, addr));
//	else RMDBGPRINT((ENABLE, "Failed to write 0x%02X to i2c 0x%02X:0x%02X\n", data, i2c.DevAddr, addr));
	return err;
}

/*
static RMstatus write_i2c_WM(
	struct RUA *pInstance, 
	RMuint8 delay, 
	RMuint32 dev, 
	RMuint32 addr, 
	RMuint32 data)
{
	RMstatus err;
	struct EMhwlibI2CDeviceParameter i2c;
	struct I2C_WriteData_type i2c_write;
	
	i2c.APIVersion = 1;
	i2c.Clock = GPIOId_Sys_0;
	i2c.Data = GPIOId_Sys_1;
	i2c.Delay = delay;
	i2c.Speed = 100;
	i2c.DevAddr = dev << 1;
	err = RUASetProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_DeviceParameter, &i2c, sizeof(i2c), 0);
	i2c_write.UseSubAddr = FALSE;
	i2c_write.SubAddr = addr;
	i2c_write.DataSize = 2;
	i2c_write.Data[0] = ((addr & 0x1F) << 1) | ((data & 0x0100) ? 1 : 0);
	i2c_write.Data[1] = data & 0xFF;
	err = RUASetProperty(pInstance, I2C_ModuleID, RMI2CPropertyID_WriteData, &i2c_write, sizeof(i2c_write), 0);
	if (RMSUCCEEDED(err)) RMDBGPRINT((ENABLE, "Wrote 0x%02X%02X to i2c 0x%02X\n", i2c_write.Data[0], i2c_write.Data[1], i2c.DevAddr));
	else RMDBGPRINT((ENABLE, "Failed to write 0x%02X%02X to i2c 0x%02X\n", i2c_write.Data[0], i2c_write.Data[1], i2c.DevAddr));
	return RM_OK;
}
*/

/**
  @delay: uSec delay between bits in i2c
  @dev: raw i2c slave address, 0x00..0x7f
*/
static RMstatus init_i2c(
	struct RUA *pInstance, 
	RMuint8 delay, 
	RMuint8 dev, 
	RMuint8 i2c_data[][2], 
	RMuint32 data_size)
{
	RMstatus err;
	RMuint32 i;
	struct EMhwlibI2CDeviceParameter i2c;
	struct I2C_WriteRMuint8_type i2c_write;
	
	i2c.APIVersion = 1;
	i2c.Clock = GPIOId_Sys_0;