capture_opt->DigitalTimingSignal, 			capture_opt->UseVideoValid, 			capture_opt->bussize, 			capture_opt->over_pos_x, 			capture_opt->over_pos_y, 			capture_opt->over_width, 			capture_opt->over_height, 			capture_opt->DualEdge, 			capture_opt->DualEdgeWidth, 			capture_opt->DualEdgeInvert, 			capture_opt->InputColorFormat, 			capture_opt->InputColorSpace, 			capture_opt->InvertVSync, 			capture_opt->InvertHSync, 			inv_fid, use_gpio);		if (RMFAILED(err)) {			RMDBGLOG((ENABLE, "Error setting graphic input: %s\n", RMstatusToString(err)));			return err;		}	} else if (capture_opt->InputModuleID == DispVideoInput) {		if (capture_opt->bussize > 16) {			RMDBGLOG((ENABLE, "video input can't capture 24 or 32 bit video!\n"));			return RM_ERROR;		}		err = DCCSetupVideoInput(dcc_info->pDCC, 			capture_opt->TVStandard, 			capture_opt->DigitalTimingSignal, 			capture_opt->UseVideoValid, 			capture_opt->bussize, 			capture_opt->over_pos_x, 			capture_opt->over_pos_y, 			capture_opt->over_width, 			capture_opt->over_height, 			capture_opt->InvertVSync, 			capture_opt->InvertHSync, 			inv_fid, use_gpio);		if (RMFAILED(err)) {			RMDBGLOG((ENABLE, "Error setting video input: %s\n", RMstatusToString(err)));			return err;		}	}		while ((err = RUASetProperty(dcc_info->pRUA, capture_opt->InputModuleID, RMGenericPropertyID_PictureOverride, &(capture_opt->override), sizeof(capture_opt->override), 0)) == RM_PENDING);	if (RMFAILED(err)) {		RMDBGLOG((ENABLE, "Cannot set PictureOverride on input: %s\n", RMstatusToString(err)));	}		if (! capture_opt->disablescaler) {		// set surface into scaler		err = DCCSetSurfaceSource(dcc_info->pDCC, dcc_info->SurfaceID, *ppVideoSource);		if (RMFAILED(err)) {			RMDBGLOG((ENABLE, "Cannot set the surface source %d\n", err));			return err;		}	}		// set up VBI capture	old_vbi_size = capture_opt->vbi_size;	capture_opt->vbi_size = 0;		// determine vbi capture mode and depending window size	if (capture_opt->vbianc_enable) {		capture_opt->vbi_h = capture_opt->vbianc_h * 2;  // assume interlaced - TODO look at input format		capture_opt->vbi_w = capture_opt->vbianc_w / 2;	} else if (capture_opt->vbiraw_topmask || capture_opt->vbiraw_botmask) {		RMuint32 top_lines, bot_lines, mask, i;		top_lines = 0;		mask = capture_opt->vbiraw_topmask;		for (i = 0; i < 24; i++) {			if (mask & 1) top_lines++;			mask >>= 1;		}		bot_lines = 0;		mask = capture_opt->vbiraw_botmask;		for (i = 0; i < 24; i++) {			if (mask & 1) bot_lines++;			mask >>= 1;		}		capture_opt->vbi_h = ((top_lines > bot_lines) ? top_lines : bot_lines) * 2;  // assume interlaced - TODO		capture_opt->vbi_w = 720;  // assume PAL or NTSC - TODO	}		// allocate VBI buffer	if (capture_opt->vbi_w && capture_opt->vbi_h) {		capture_opt->vbi_size = capture_opt->vbi_w * capture_opt->vbi_h * 2;		if (capture_opt->vbi_dma) {			if (ppR && ppDmaReceive) {				struct Receive_type Receive;				Receive.pRUA = dcc_info->pRUA;				Receive.targetModule = EMHWLIB_TARGET_MODULE(					EMHWLIB_MODULE_CATEGORY(capture_opt->InputModuleID), 					EMHWLIB_MODULE_INDEX(capture_opt->InputModuleID), 					1);				Receive.buffer_count = 4;				Receive.buffer_size_log2 = 15;  // 32k per buffer -> 128k				Receive.threshold_size = 1 << Receive.buffer_size_log2;  /* every buffer we receive interrupt */				Receive.partial_read = FALSE;				err = DCCOpenReceive(&Receive, ppR, ppDmaReceive);			}//			capture_opt->vbi_buf = 0;			capture_opt->vbi_size += 12;  // size of one VBI data block, including header//			if (ppVBIData) *ppVBIData = NULL;		} else {			if (ppVBIData) {				if (((old_vbi_size / 300 - 12) != capture_opt->vbi_size) && *ppVBIData) {					RMFree(*ppVBIData);					*ppVBIData = NULL;					if (capture_opt->vbi_buf) {						RUAFree(dcc_info->pRUA, capture_opt->vbi_buf);						capture_opt->vbi_buf = 0;					}				}				if (! *ppVBIData) *ppVBIData = (RMuint16 *)RMMalloc(capture_opt->vbi_size);			}			capture_opt->vbi_size = (capture_opt->vbi_size + 12) * 300;  // number of VBI buffers			if (! capture_opt->vbi_buf) {				capture_opt->vbi_buf = DCCMalloc(dcc_info->pDCC, 0, RUA_DRAM_UNCACHED, capture_opt->vbi_size);			}			printf("Storing 0x%08lX bytes of VBI data from 0x%08lX to 0x%08lX\n", 				capture_opt->vbi_size, capture_opt->vbi_buf, capture_opt->vbi_buf + capture_opt->vbi_size);//			if (ppDmaReceive) *ppDmaReceive = NULL;//			if (ppR) *ppR = NULL;		}	}		// enable/disable ANC type vbi capture	err = DCCSetupVBICaptureANC(dcc_info->pDCC, capture_opt->InputModuleID, 		capture_opt->vbianc_enable, 		capture_opt->vbianc_w, capture_opt->vbianc_h, 		capture_opt->vbianc_ytop, capture_opt->vbianc_ybot, 		capture_opt->vbi_dma ? 0 : capture_opt->vbi_buf, capture_opt->vbi_dma ? 0 : capture_opt->vbi_size);	if (RMFAILED(err)) return err;		// enable/disable Raw type vbi capture	err = DCCSetupVBICaptureRaw(dcc_info->pDCC, capture_opt->InputModuleID, 		capture_opt->vbiraw_topstart, capture_opt->vbiraw_topmask, 		capture_opt->vbiraw_botstart, capture_opt->vbiraw_botmask, 		capture_opt->vbi_dma ? 0 : capture_opt->vbi_buf, capture_opt->vbi_dma ? 0 : capture_opt->vbi_size);	if (RMFAILED(err)) return err;		// enable 601 type vbi capture	if (		(! capture_opt->vbianc_enable) &&  // is not ANC,		(! (capture_opt->vbiraw_topmask || capture_opt->vbiraw_botmask)) &&  // is not Raw,		capture_opt->vbi_w && capture_opt->vbi_h  // but window defined --> is 601	) {		err = DCCSetupVBICapture(dcc_info->pDCC, capture_opt->InputModuleID, 			capture_opt->vbi_x, capture_opt->vbi_y, 			capture_opt->vbi_w, capture_opt->vbi_h, 			capture_opt->vbi_dma ? 0 : capture_opt->vbi_buf, capture_opt->vbi_dma ? 0 : capture_opt->vbi_size);		if (RMFAILED(err)) return err;	}		return RM_OK;}RMstatus apply_capture_options(	struct dcc_context *dcc_info, 	struct DCCVideoSource **ppVideoSource, 	struct capture_cmdline *options, 	RMuint16 **ppVBIData, 	struct ReceiveObject_type **ppR, 	struct RUABufferPool **ppDmaReceive, 	RMuint32 TimerNumber, 	RMbool use_gpio, 	RMbool inv_fid){	RMstatus err;		// set up the input	err = setup_capture(dcc_info, ppVideoSource, options, ppVBIData, ppR, ppDmaReceive, TimerNumber, use_gpio, inv_fid);	if (RMFAILED(err)) return err;		return RM_OK;}RMstatus guess_capture_format(	struct dcc_context *dcc_info, 	struct capture_cmdline *options){	RMstatus err;	RMuint64 XtalPerField = 0, ClocksPerField = 0, LinesPerField = 0, ClocksPerLine = 0;	RMuint32 i, samples = 0;	RMuint32 VFreq;		// sample sets of values for averaging	for (i = 0; i < 50; i++) {  // half second		struct Input_Detect_type det;		err = RUAGetProperty(dcc_info->pRUA, options->InputModuleID, 			RMGenericPropertyID_Detect, 			&det, sizeof(det));		if (RMFAILED(err)) printf("Error getting property Detect: %s\n", RMstatusToString(err));		if (i >= 3) {  // skip first three measurements			XtalPerField += det.XtalPerField;			ClocksPerField += det.ClocksPerField;			LinesPerField += det.LinesPerField;			ClocksPerLine += det.ClocksPerLine;			samples++;		}		usleep(10000);	}		// average sampled values	VFreq = XtalPerField ? 2700000000U / (RMuint32)(XtalPerField / samples) : 0;	ClocksPerField /= samples;	LinesPerField /= samples;	ClocksPerLine /= samples;		//printf("Guessing captured video format\n  Measured values are: %ld.%02ld Hz, %ld pix/field, %ld lines/field, %ld pix/line\n", 	//	VFreq / 100, VFreq % 100, 	//	(RMuint32)ClocksPerField, 	//	(RMuint32)LinesPerField, 	//	(RMuint32)ClocksPerLine);		// maintain minimum thresholds: 10 Hz, 10000 cpf, 48 lpf, 128 cpl	if (		(VFreq && (VFreq < 1000)) || 		(ClocksPerField && (ClocksPerField < 10000)) || 		(LinesPerField && (LinesPerField < 48)) || 		(ClocksPerLine && (ClocksPerLine < 128))	) {		printf("No Video!\n");		return RM_ERROR;	}		// match with closest TVStandard	{		enum EMhwlibTVStandard prevTVStandard = options->TVStandard;		enum EMhwlibTVStandard best_match = EMhwlibTVStandard_Custom;		RMuint32 curr_VFreq, curr_ClocksPerField, curr_HalfLinesPerField, curr_ClocksPerLine;		RMint32 diff_VFreq, diff_ClocksPerField, diff_LinesPerField, diff_ClocksPerLine;		RMuint64 err, min_err = 0xFFFFFFFFFFFFFFFFULL;		RMascii *StandardName;				options->TVStandard = 1;		while (RMSUCCEEDED(GetTVStandardName(options->TVStandard, &StandardName))) {			struct EMhwlibTVFormatDigital dig;			RMuint32 dig_clk;						err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, 				RMDisplayBlockPropertyID_TVFormatDigital, 				&(options->TVStandard), sizeof(options->TVStandard), 				&dig, sizeof(dig));			if RMFAILED(err) {				RMDBGLOG((ENABLE, "Could not get format for TV Standard %s!\n", StandardName));				return err;			}			err = RUAExchangeProperty(dcc_info->pRUA, DisplayBlock, 				RMDisplayBlockPropertyID_TVPixelClockDigital, 				&(options->TVStandard), sizeof(options->TVStandard), 				&dig_clk, sizeof(dig_clk));			if RMFAILED(err) {				RMDBGLOG((ENABLE, "Could not get pixel clock for TV Standard %s!\n", StandardName));				return err;			}			curr_HalfLinesPerField = dig.VTotalSize;			if (! dig.TopFieldHeight) curr_HalfLinesPerField *= 2;			curr_ClocksPerLine = dig.HTotalSize;			if (options->bussize == 8) curr_ClocksPerLine *= 2;			curr_ClocksPerField = curr_HalfLinesPerField * curr_ClocksPerLine / 2;			if (options->bussize == 8) dig_clk *= 2;			curr_VFreq = (RMuint32)((RMuint64)dig_clk * 100L / curr_ClocksPerField);						if (0) printf("Mode: %s - %ld Hz, %ld.%02ld Hz, %ld pix/field, %ld lines/field, %ld pix/line\n", 				StandardName, dig_clk, 				curr_VFreq / 100, curr_VFreq % 100, 				curr_ClocksPerField, 				curr_HalfLinesPerField / 2, 				curr_ClocksPerLine);						diff_VFreq = (VFreq) ? VFreq - curr_VFreq : 0;			diff_ClocksPerField = (ClocksPerField) ? ClocksPerField - curr_ClocksPerField : 0;			diff_LinesPerField = (LinesPerField) ? LinesPerField - curr_HalfLinesPerField / 2 : 0;			diff_ClocksPerLine = (ClocksPerLine) ? ClocksPerLine - curr_ClocksPerLine : 0;			err = diff_VFreq * diff_VFreq + diff_ClocksPerField * diff_ClocksPerField +				diff_LinesPerField * diff_LinesPerField + diff_ClocksPerLine * diff_ClocksPerLine;						if (0) printf("deviation: dist^2: %llu (min = %llu) diff: %s%d.%02d Hz, %ld pix/field, %ld lines/field, %ld pix/line\n", 				err, min_err, 				(diff_VFreq < 0) ? "-" : "", abs(diff_VFreq) / 100, abs(diff_VFreq) % 100, 				diff_ClocksPerField, 				diff_LinesPerField / 2, 				diff_ClocksPerLine);						if (err < min_err) {				min_err = err;				best_match = options->TVStandard;			}						options->TVStandard ++;		}				if (best_match != EMhwlibTVStandard_Custom) {			options->TVStandard = best_match;		} else {			options->TVStandard = prevTVStandard;		}	}		return RM_OK;}RMstatus close_capture(	struct dcc_context *dcc_info, 	struct DCCVideoSource **ppVideoSource, 	struct capture_cmdline *capture_opt, 	RMuint16 **ppVBIData, 	struct ReceiveObject_type **ppR, 	struct RUABufferPool **ppDmaReceive){	RMstatus err;		// disable ANC type vbi capture	err = DCCSetupVBICaptureANC(dcc_info->pDCC, capture_opt->InputModuleID, 		FALSE, 0, 0, 0, 0, 0, 0);	if (RMFAILED(err)) return err;		// disable Raw type vbi capture	err = DCCSetupVBICaptureRaw(dcc_info->pDCC, capture_opt->InputModuleID, 		0, 0, 0, 0, 0, 0);	if (RMFAILED(err)) return err;		// disable 601 type vbi capture	err = DCCSetupVBICapture(dcc_info->pDCC, capture_opt->InputModuleID, 		0, 0, 0, 0, 0, 0);	if (RMFAILED(err)) return err;		// close input and remove old surface	if (ppVideoSource && *ppVideoSource) {		//fprintf(stderr, "Closing VideoSource\n");		err = DCCCloseVideoSource(*ppVideoSource);		*ppVideoSource = NULL;		if (RMFAILED(err)) {			RMDBGLOG((ENABLE, "Could not clean surface: %s\n", RMstatusToString(err)));		}	}		// TODO closing DMA fails, needs to be fixed!!!	// close old VBI capture, if any	if (ppR && *ppR) {//		RMuint32 n;		fprintf(stderr, "Closing DMA VBI receiver\n");//		n = 25;//		do {//			if (ppDmaReceive && *ppDmaReceive) {//				RMuint8 *pBuf = NULL;//				RMuint32 size = 0;//				RMuint32 targetModule = EMHWLIB_TARGET_MODULE(//					EMHWLIB_MODULE_CATEGORY(capture_opt->InputModuleID), //					EMHWLIB_MODULE_INDEX(capture_opt->InputModuleID), //					1);//				fprintf(stderr, "Receiving remaining DMA buffers\n");//				do {//					err = RUAReceiveData(dcc_info->pRUA, targetModule, *ppDmaReceive, &pBuf, &size, NULL, NULL);//					fprintf(stderr, "RUAReceiveData(): %s, %p, %lu\n", RMstatusToString(err), pBuf, size);//					if (RMSUCCEEDED(err) && pBuf && size) {//						RUAReleaseBuffer(*ppDmaReceive, pBuf);//					}//				} while (RMSUCCEEDED(err) /*|| (err == RM_PENDING)*/);//			}//			if ((*ppR)->pDMA) err = RUAResetPool((*ppR)->pDMA);//			else err = RM_OK;//		} while (--n && RMFAILED(err));		//DCCResetReceive(*ppR);//		DCCCloseReceive(*ppR);		//*ppR = NULL;	}	if (ppVBIData && *ppVBIData) {		fprintf(stderr, "Releasing VBIData buffer\n");		RMFree(*ppVBIData);		*ppVBIData = NULL;	}	if (capture_opt->vbi_buf) {		fprintf(stderr, "Releasing vbi_buf\n");		DCCFree(dcc_info->pDCC, capture_opt->vbi_buf);		capture_opt->vbi_buf = 0;	}		return err;}