play_rmcapture.c

1. 8623L平台

			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 (RMCompareAscii(&(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 (RMCompareAscii(&(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 (RMCompareAscii(&(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 (RMCompareAscii(&(argv[argi][1]), "vbiprint")) {
			options->dump_vbi = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "anc")) {
			options->parse_anc = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "ancprint")) {
			options->parse_anc = TRUE;
			options->print_anc = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "m")) {
			SCANPARAM(options->chip_num, "please specify a chip number", 1);
		}
		else if (RMCompareAscii(&(argv[argi][1]), "i2ccc")) {
			if ((argi + 1 >= argc) || (argv[argi + 1][0] == '-')) {
				options->enable_i2c_cc = TRUE;  // only for SAA 7119
			} else {
				if (RMCompareAscii(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 (RMCompareAscii(&(argv[argi][1]), "i2cwss")) {
			options->enable_i2c_wss = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "ccprint")) {
			options->ccfifo_print = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "softcc")) {
			options->use_soft_cc_decoder = 1;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "softcc608")) {
			options->use_soft_cc_decoder = 1;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "softcc708")) {
			options->use_soft_cc_decoder = 2;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "i2c")) {
			SCANPARAM(options->i2c_module, "please specify a i2c module number", 1);
		}
		else if (RMCompareAscii(&(argv[argi][1]), "I")) {
			if (argi + 2 >= argc) goto SKIP;
			argi++;
			if (RMCompareAscii(argv[argi], "775")) {
				options->board = cap_board_sigma775avinput;
			} else if (RMCompareAscii(argv[argi], "871e1")) {
				options->board = cap_board_sigma871e1odyssey;
			} else if (RMCompareAscii(argv[argi], "760e1")) {
				options->board = cap_board_sigma760e1dtv8620;
			} else if (RMCompareAscii(argv[argi], "760e2")) {
				options->board = cap_board_sigma760e2dtv8620;
			} else if (RMCompareAscii(argv[argi], "844e1")) {
				options->board = cap_board_sigma844e1dtv8624;
			} else if (RMCompareAscii(argv[argi], "904e1")) {
				options->board = cap_board_sigma904e1dtv8634;
			} else if (RMCompareAscii(argv[argi], "jamo")) {
				options->board = cap_board_kissjamoplasma;
			} else {
				fprintf(stderr, "unknown capture board: %s\n", argv[argi]);
				err = RM_ERROR;
				goto SKIP;
			}
			SCANPARAM(options->input_num, "please specify a input number", 2);
		}
		else if (RMCompareAscii(&(argv[argi][1]), "update")) {
			options->update = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "gpiofid")) {
			options->use_gpio_fid = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "fidinv")) {
			options->invert_fid = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "eq")) {
			SCANPARAM(options->cable_eq, "please specify a cable length", 1);
			options->cable_eq &= 0x0F;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "fv")) {
			options->follow_vfreq = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "v")) {
			if (options->verbouse) options->intr_debug = TRUE;
			options->verbouse = TRUE;
		}
		else if (RMCompareAscii(&(argv[argi][1]), "bg")) {
			options->green_bg = TRUE;
		}
		else if (RMCompareAscii(&(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);
}

RMuint32 input_num = 0;
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 (RMCompareAscii(&(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;
	struct rmcapture_instance *pCapture;
	// TODO etc.
} myapp_capture_context;

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

static RMstatus transfer_capture_options(
	struct rmcapture_options *rmcapture_options, // target
	struct capture_cmdline *capture_opt, 
	struct display_cmdline *disp_opt, 
	struct audio_cmdline *audio_opt, 
	struct local_cmdline *local_opt)
{
	rmcapture_options->STCTimerNumber = local_opt->TimerNumber;
	
	// Video
	rmcapture_options->force_TVStandard = ! capture_opt->guess;
	rmcapture_options->TVStandard = capture_opt->TVStandard;
	rmcapture_options->dram = capture_opt->dram;  // number of the DRAM bank to use
	rmcapture_options->InputColorSpace = capture_opt->InputColorSpace;
	rmcapture_options->SurfaceColorSpace = capture_opt->SurfaceColorSpace;
	rmcapture_options->SamplingMode = capture_opt->SamplingMode;
	rmcapture_options->ColorMode = capture_opt->ColorMode;
	rmcapture_options->InputColorFormat = capture_opt->InputColorFormat;
	rmcapture_options->InputModuleID = capture_opt->InputModuleID;
	rmcapture_options->DigitalTimingSignal = capture_opt->DigitalTimingSignal;
	rmcapture_options->UseVideoValid = capture_opt->UseVideoValid;
	rmcapture_options->bussize = capture_opt->bussize;
	rmcapture_options->DualEdge = capture_opt->DualEdge;
	rmcapture_options->DualEdgeWidth = capture_opt->DualEdgeWidth;
	rmcapture_options->DualEdgeInvert = capture_opt->DualEdgeInvert;
	rmcapture_options->InvertVSync = capture_opt->InvertVSync;
	rmcapture_options->InvertHSync = capture_opt->InvertHSync;
	rmcapture_options->shift_x = capture_opt->shift_x;  // shifting of the capture frame on the input field
	rmcapture_options->shift_y = capture_opt->shift_y;