コード例 #1
0
int CVxParamDistribution::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
	// save reference object and get object attributes
	m_vxObjRef = ref;
	m_distribution = (vx_distribution)m_vxObjRef;
	ERROR_CHECK(vxQueryDistribution(m_distribution, VX_DISTRIBUTION_ATTRIBUTE_BINS, &m_numBins, sizeof(m_numBins)));
	ERROR_CHECK(vxQueryDistribution(m_distribution, VX_DISTRIBUTION_ATTRIBUTE_OFFSET, &m_offset, sizeof(m_offset)));
	ERROR_CHECK(vxQueryDistribution(m_distribution, VX_DISTRIBUTION_ATTRIBUTE_RANGE, &m_range, sizeof(m_range)));

	// process I/O parameters
	if (*io_params == ':') io_params++;
	while (*io_params) {
		char ioType[64], fileName[256];
		io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
		if (!_stricmp(ioType, "read"))
		{ // read request syntax: read,<fileName>[,ascii|binary]
			m_fileNameRead.assign(RootDirUpdated(fileName));
			m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
			m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_readFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_readFileIsBinary = true;
				}
				else ReportError("ERROR: invalid distribution read option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "write"))
		{ // write request syntax: write,<fileName>[,ascii|binary]
			m_fileNameWrite.assign(RootDirUpdated(fileName));
			m_writeFileIsBinary = (m_fileNameWrite.find(".txt") != m_fileNameWrite.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_writeFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_writeFileIsBinary = true;
				}
				else ReportError("ERROR: invalid distribution write option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "compare"))
		{ // compare syntax: compare,fileName[,ascii|binary]
			m_fileNameCompare.assign(RootDirUpdated(fileName));
			m_compareFileIsBinary = (m_fileNameCompare.find(".txt") != m_fileNameCompare.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_compareFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_compareFileIsBinary = true;
				}
				else ReportError("ERROR: invalid distribution compare option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "view")) {
			m_displayName.assign(fileName);
			m_paramList.push_back(this);
		}
		else ReportError("ERROR: invalid distribution operation: %s\n", ioType);
		if (*io_params == ':') io_params++;
		else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
	}

	return 0;
}
コード例 #2
0
int CVxParamArray::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
	// save reference object and get object attributes
	m_vxObjRef = ref;
	m_array = (vx_array)m_vxObjRef;
	ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &m_format, sizeof(m_format)));
	ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_CAPACITY, &m_capacity, sizeof(m_capacity)));
	ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_ITEMSIZE, &m_itemSize, sizeof(m_itemSize)));

	// process I/O parameters
	if (*io_params == ':') io_params++;
	while (*io_params) {
		char ioType[64], fileName[256];
		io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
		if (!_stricmp(ioType, "read"))
		{ // read request syntax: read,<fileName>[,ascii|binary]
			m_fileNameRead.assign(RootDirUpdated(fileName));
			m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
			m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_readFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_readFileIsBinary = true;
				}
				else ReportError("ERROR: invalid array read option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "write"))
		{ // write request syntax: write,<fileName>[,ascii|binary]
			m_fileNameWrite.assign(RootDirUpdated(fileName));
			m_writeFileIsBinary = (m_fileNameWrite.find(".txt") != m_fileNameWrite.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_writeFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_writeFileIsBinary = true;
				}
				else ReportError("ERROR: invalid array write option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "compare"))
		{ // compare syntax: compare,fileName[,ascii|binary][,err{<x>;<y>[;<strength>][;<%mismatch>]}][,log{<fileName>}]
			m_fileNameCompareLog = "";
			m_fileNameCompare.assign(RootDirUpdated(fileName));
			m_compareFileIsBinary = (m_fileNameCompare.find(".txt") != m_fileNameCompare.npos) ? false : true;
			while (*io_params == ',') {
				char option[256];
				io_params = ScanParameters(io_params, ",ascii|binary|err{<x>;<y>[;<strength>][;<%mismatch>]}|log{<fileName>}", ",S", option);
				if (!_stricmp(option, "ascii")) {
					m_compareFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_compareFileIsBinary = true;
				}
				else if (!_strnicmp(option, "err{", 4)) {
					if (m_format == VX_TYPE_KEYPOINT) {
						const char * p = ScanParameters(&option[3], "{<x>;<y>;<strength>[;<%mismatch>]}", "{d;d;f", &m_errX, &m_errY, &m_errStrength);
						if (*p == ';') {
							ScanParameters(p, ";<%mismatch>}", ";f}", &m_errMismatchPercent);
						}
					}
					else if (m_format == VX_TYPE_COORDINATES2D) {
						const char * p = ScanParameters(&option[3], "{<x>;<y>[;<%mismatch>]}", "{d;d", &m_errX, &m_errY);
						if (*p == ';') {
							ScanParameters(p, ";<%mismatch>}", ";f}", &m_errMismatchPercent);
						}
					}
					else ReportError("ERROR: array compare option not supported for this array: %s\n", option);
				}
				else if (!_strnicmp(option, "log{", 4)) {
					option[strlen(option) - 1] = 0;
					m_fileNameCompareLog.assign(RootDirUpdated(&option[4]));
				}
				else ReportError("ERROR: invalid array compare option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "view")) {
			m_displayName.assign(fileName);
			m_paramList.push_back(this);
		}
		else if (!_stricmp(ioType, "directive") && (!_stricmp(fileName, "VX_DIRECTIVE_AMD_COPY_TO_OPENCL") || !_stricmp(fileName, "sync-cl-write"))) {
			m_useSyncOpenCLWriteDirective = true;
		}
		else if (!_stricmp(ioType, "init")) {
			m_fileNameRead.assign(RootDirUpdated(fileName));
			m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
			m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_readFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_readFileIsBinary = true;
				}
				else ReportError("ERROR: invalid array init option: %s\n", option);
			}
			if (ReadFrame(0) < 0)
				ReportError("ERROR: reading from input file for array init\n");
		}
		else ReportError("ERROR: invalid array operation: %s\n", ioType);
		if (*io_params == ':') io_params++;
		else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
	}

	return 0;
}
コード例 #3
0
int CVxParamRemap::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
	// save reference object and get object attributes
	m_vxObjRef = ref;
	m_remap = (vx_remap)m_vxObjRef;
	ERROR_CHECK(vxQueryRemap(m_remap, VX_REMAP_ATTRIBUTE_SOURCE_WIDTH, &m_srcWidth, sizeof(m_srcWidth)));
	ERROR_CHECK(vxQueryRemap(m_remap, VX_REMAP_ATTRIBUTE_SOURCE_HEIGHT, &m_srcHeight, sizeof(m_srcHeight)));
	ERROR_CHECK(vxQueryRemap(m_remap, VX_REMAP_ATTRIBUTE_DESTINATION_WIDTH, &m_dstWidth, sizeof(m_dstWidth)));
	ERROR_CHECK(vxQueryRemap(m_remap, VX_REMAP_ATTRIBUTE_DESTINATION_HEIGHT, &m_dstHeight, sizeof(m_dstHeight)));

	// process I/O parameters
	if (*io_params == ':') io_params++;
	while (*io_params) {
		char ioType[64], fileName[256];
		io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
		if (!_stricmp(ioType, "read")) {
			m_fileNameRead.assign(RootDirUpdated(fileName));
			m_usingMultiFrameCapture = (m_fileNameRead.find("%") != std::string::npos) ? true : false;
			m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_readFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_readFileIsBinary = true;
				}
				else ReportError("ERROR: invalid remap read option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "write")) {
			m_fileNameWrite.assign(RootDirUpdated(fileName));
		}
		else if (!_stricmp(ioType, "compare"))
		{ // compare request syntax: compare,<fileName>[,err{<x>;<y>}]
			m_fileNameCompare.assign(RootDirUpdated(fileName));
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",err{<x>;<y>}", ",s", option);
				if (!_strnicmp(option, "err{", 4)) {
					ScanParameters(&option[3], "{<errX>;<errY>}", "{f;f}", &m_xyErr[0], &m_xyErr[1]);
				}
				else ReportError("ERROR: invalid remap compare option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "directive") && (!_stricmp(fileName, "VX_DIRECTIVE_AMD_COPY_TO_OPENCL") || !_stricmp(fileName, "sync-cl-write"))) {
			m_useSyncOpenCLWriteDirective = true;
		}
		else if (!_stricmp(ioType, "init")) {
			const char * patternName = fileName;
			if (!_stricmp(patternName, "same")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (vx_float32)x, sy = (vx_float32)y;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else if (!_stricmp(patternName, "rotate-90")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (vx_float32)m_dstHeight - 1 - y, sy = (vx_float32)x;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else if (!_stricmp(patternName, "rotate-180")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (vx_float32)m_dstWidth - 1 - x, sy = (vx_float32)m_dstHeight - 1 - y;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else if (!_stricmp(patternName, "rotate-270")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (vx_float32)y, sy = (vx_float32)m_dstWidth - 1 - x;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else if (!_stricmp(patternName, "scale")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (x + 0.5f) * (vx_float32)m_srcWidth / (vx_float32)m_dstWidth - 0.5f;
						vx_float32 sy = (y + 0.5f) * (vx_float32)m_srcHeight / (vx_float32)m_dstHeight - 0.5f;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else if (!_stricmp(patternName, "hflip")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (vx_float32)m_dstWidth - 1 - x, sy = (vx_float32)y;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else if (!_stricmp(patternName, "vflip")) {
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 sx = (vx_float32)x, sy = (vx_float32)m_dstHeight - 1 - y;
						vx_status status = vxSetRemapPoint(m_remap, x, y, sx, sy);
						if (status) {
							printf("ERROR: vxSetRemapPoint(*,%d,%d,%g,%g) failed, status = %d\n", x, y, sx, sy, status);
							return -1;
						}
					}
				}
			}
			else {
				// initialize from binary file
				FILE * fp = fopen(fileName, "rb");
				if (!fp) ReportError("ERROR: CVxParamRemap::InitializeIO: unable to open: %s\n", fileName);
				for (vx_uint32 y = 0; y < m_dstHeight; y++){
					for (vx_uint32 x = 0; x < m_dstWidth; x++){
						vx_float32 src_xy[2];
						if (fread(src_xy, sizeof(src_xy), 1, fp) != 1)
							ReportError("ERROR: detected EOF at (%d,%d) on remap input file: %s\n", x, y, fileName);
						ERROR_CHECK(vxSetRemapPoint(m_remap, x, y, src_xy[0], src_xy[1]));
					}
				}
				fclose(fp);
			}
		}
		else {
			printf("ERROR: invalid remap I/O operation: %s\n", ioType);
			return -1;
		}
		if (*io_params == ':') io_params++;
		else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
	}
	return 0;
}
コード例 #4
0
int CVxParamTensor::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
	// save reference object and get object attributes
	m_vxObjRef = ref;
	m_tensor = (vx_tensor)m_vxObjRef;
	ERROR_CHECK(vxQueryTensor(m_tensor, VX_TENSOR_NUMBER_OF_DIMS, &m_num_of_dims, sizeof(m_num_of_dims)));
	ERROR_CHECK(vxQueryTensor(m_tensor, VX_TENSOR_DIMS, &m_dims, sizeof(m_dims[0])*m_num_of_dims));
	ERROR_CHECK(vxQueryTensor(m_tensor, VX_TENSOR_DATA_TYPE, &m_data_type, sizeof(m_data_type)));
	ERROR_CHECK(vxQueryTensor(m_tensor, VX_TENSOR_FIXED_POINT_POSITION, &m_fixed_point_pos, sizeof(vx_uint8)));
	if(m_data_type == VX_TYPE_UINT8 || m_data_type == VX_TYPE_INT8)
		m_size = 1;
	else if(m_data_type == VX_TYPE_UINT16 || m_data_type == VX_TYPE_INT16 || m_data_type == VX_TYPE_FLOAT16)
		m_size = 2;
	else
	    m_size = 4;
	for (vx_uint32 i = 0; i < m_num_of_dims; i++) {
		m_stride[i] = m_size;
		m_size *= m_dims[i];
	}
	m_data = new vx_uint8[m_size];
	if (!m_data) ReportError("ERROR: memory allocation failed for tensor: %u\n", (vx_uint32)m_size);

	// process I/O parameters
	if (*io_params == ':') io_params++;
	while (*io_params) {
		char ioType[64], fileName[256];
		io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
		if (!_stricmp(ioType, "read"))
		{ // read request syntax: read,<fileName>[,ascii|binary]
			m_fileNameRead.assign(RootDirUpdated(fileName));
			m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
			m_readFileIsBinary = true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",binary", ",s", option);
				if (!_stricmp(option, "binary")) {
					m_readFileIsBinary = true;
				}
				else ReportError("ERROR: invalid tensor read option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "init"))
		{ // init request syntax: init,<fileName>
			if(!_strnicmp(fileName, "@fill~f32~", 10)) {
				float value = (float)atof(&fileName[10]);
				float * buf = (float *)m_data;
				for(size_t i = 0; i < m_size/4; i++)
					buf[i] = value;
			}
			else if(!_strnicmp(fileName, "@fill~i32~", 10)) {
				vx_int32 value = atoi(&fileName[10]);
				vx_int32 * buf = (vx_int32 *)m_data;
				for(size_t i = 0; i < m_size/4; i++)
					buf[i] = value;
			}
			else if(!_strnicmp(fileName, "@fill~i16~", 10)) {
				vx_int16 value = (vx_int16)atoi(&fileName[10]);
				vx_int16 * buf = (vx_int16 *)m_data;
				for(size_t i = 0; i < m_size/2; i++)
					buf[i] = value;
			}
			else if(!_strnicmp(fileName, "@fill~u8~", 9)) {
				int value = atoi(&fileName[9]);
				memset(m_data, value, m_size);
			}
			else {
				int count = 1;
				const char * tensorFileName = fileName;
				if(!_strnicmp(tensorFileName, "@repeat~", 8)) {
					tensorFileName += 8;
					for(count = 0; *tensorFileName >= '0' && *tensorFileName <= '9'; tensorFileName++) {
						count = count * 10 + *tensorFileName - '0';
					}
					if(*tensorFileName++ != '~' || count < 1)
						ReportError("ERROR: invalid init @repeat~<n>~fileName syntax -- %s\n", fileName);
					if((m_size % count) != 0)
						ReportError("ERROR: file size is not multiple of tensor size -- %s\n", fileName);
				}
				if(!_stricmp(fileName + strlen(fileName) - 4, ".dat")) {
					ReportError("ERROR: read from .dat files not supported: %s\n", fileName);
				}
				FILE * fp = fopen(RootDirUpdated(tensorFileName), "rb");
				if (!fp) {
					ReportError("ERROR: Unable to open: %s\n", tensorFileName);
				}
				vx_size size = m_size / count;
				if (fread(m_data, 1, size, fp) != size)
					ReportError("ERROR: not enough data (%d bytes) in %s\n", (vx_uint32)size, tensorFileName);
				for(int i = 1; i < count; i++) {
					memcpy(m_data + i * size, m_data, size);
				}
				vx_status status = vxCopyTensorPatch(m_tensor, m_num_of_dims, nullptr, nullptr, m_stride, m_data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST);
				fclose(fp);
				if (status != VX_SUCCESS)
					ReportError("ERROR: vxCopyTensorPatch: write failed (%d)\n", status);
			}
		}
		else if (!_stricmp(ioType, "write"))
		{ // write request syntax: write,<fileName>[,ascii|binary]
			m_fileNameWrite.assign(RootDirUpdated(fileName));
			m_writeFileIsBinary = true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",binary", ",s", option);
				if (!_stricmp(option, "binary")) {
					m_writeFileIsBinary = true;
				}
				else ReportError("ERROR: invalid tensor write option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "compare"))
		{ // write request syntax: compare,<fileName>[,ascii|binary]
			m_fileNameCompare.assign(RootDirUpdated(fileName));
			m_compareFileIsBinary = true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",binary|maxerr=<value>|avgerr=<value>", ",s", option);
				if (!_stricmp(option, "binary")) {
					m_compareFileIsBinary = true;
				}
				else if (!_strnicmp(option, "maxerr=", 7)) {
					m_maxErrorLimit = (float)atof(&option[7]);
					m_avgErrorLimit = 1e20f;
				}
				else if (!_strnicmp(option, "avgerr=", 7)) {
					m_avgErrorLimit = (float)atof(&option[7]);
					m_maxErrorLimit = 1e20f;
				}
				else ReportError("ERROR: invalid tensor compare option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "directive") && (!_stricmp(fileName, "VX_DIRECTIVE_AMD_COPY_TO_OPENCL") || !_stricmp(fileName, "sync-cl-write"))) {
			m_useSyncOpenCLWriteDirective = true;
		}
		else ReportError("ERROR: invalid tensor operation: %s\n", ioType);
		if (*io_params == ':') io_params++;
		else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
	}

	return 0;
}
コード例 #5
0
ファイル: runvx.cpp プロジェクト: Badiboy/amdovx-core
int main(int argc, char * argv[])
{	
	// process command-line options
	const char * program = "runvx.exe";
	bool verbose = false;
	bool enableMultiFrameProcessing = false;
	bool framesEofRequested = true;
	bool enableDumpGDF = false, enableScheduleGraph = false;
	bool pauseBeforeExit = false;
	bool enableDumpProfile = false;
	bool disableVirtual = false;
	bool discardCompareErrors = false;
	vx_uint32 defaultTargetAffinity = 0;
	vx_uint32 defaultTargetInfo = 0;
	bool doSetGraphOptimizerFlags = false;
	vx_uint32 graphOptimizerFlags = 0;
	int arg, frameStart = 0, frameEnd = 1;
	bool frameCountSpecified = false;
	int waitKeyDelayInMilliSeconds = -1; // -ve indicates no user preference
	for (arg = 1; arg < argc; arg++){
		if (argv[arg][0] == '-'){
			if (!_stricmp(argv[arg], "-h")) {
				show_usage(program, true);
				exit(0);
			}
			else if (!_stricmp(argv[arg], "-v")) {
				verbose ^= true;
			}
			else if (!strncmp(argv[arg], "--", 2)) { // skip specified number of arguments: --[#] (default just skip --)
				arg += atoi(&argv[arg][2]);
			}
			else if (!_strnicmp(argv[arg], "-root:", 6)) {
				SetRootDir(argv[arg] + 6);
			}
			else if (!_strnicmp(argv[arg], "-frames:", 8)) {
				int spos = 8;
				while (argv[arg][spos]) {
					if (argv[arg][spos] == ',')
						spos++;
					else if (!_strnicmp(argv[arg], "live", 4)) {
						enableMultiFrameProcessing = true;
						spos += 4;
					}
					else if (!_strnicmp(argv[arg], "eof", 3)) {
						framesEofRequested = true;
						spos += 3;
					}
					else {
						int k = sscanf(&argv[arg][spos], "%d:%d", &frameStart, &frameEnd);
						if (k == 1) { frameEnd = frameStart, frameStart = 0; }
						else if (k != 2) { printf("ERROR: invalid -frames option\n"); return -1; }
						frameCountSpecified = true;
						while (argv[arg][spos] && argv[arg][spos] != ',')
							spos++;
					}
				}
			}
			else if (!_strnicmp(argv[arg], "-affinity:", 10)) {
				if (!_strnicmp(&argv[arg][10], "cpu", 3)) defaultTargetAffinity = AGO_TARGET_AFFINITY_CPU;
				else if (!_strnicmp(&argv[arg][10], "gpu", 3)) defaultTargetAffinity = AGO_TARGET_AFFINITY_GPU;
				else { printf("ERROR: unsupported affinity target: %s\n", &argv[arg][10]); return -1; }
				if (argv[arg][13] >= '0' && argv[arg][13] <= '9')
					defaultTargetInfo = atoi(&argv[arg][13]);
			}
			else if (!_stricmp(argv[arg], "-dump-profile")) {
				enableDumpProfile = true;
			}
			else if (!_stricmp(argv[arg], "-dump-gdf") || !_stricmp(argv[arg], "-ago-dump")) { // TBD: remove -ago-dump
				enableDumpGDF = true;
			}
			else if (!_stricmp(argv[arg], "-discard-compare-errors")) {
				discardCompareErrors = true;
			}
			else if (!_stricmp(argv[arg], "-use-schedule-graph")) {
				enableScheduleGraph = true;
			}
			else if (!_stricmp(argv[arg], "-disable-virtual")) {
				disableVirtual = true;
			}
			else if (!_strnicmp(argv[arg], "-graph-optimizer-flags:", 23)) {
				if (sscanf(&argv[arg][23], "%i", &graphOptimizerFlags) == 1) {
					doSetGraphOptimizerFlags = true;
				}
				else { printf("ERROR: invalid graph optimizer flags: %s\n", argv[arg]); return -1; }
			}
			else if (!_strnicmp(argv[arg], "-key-wait-delay:", 16)) {
				(void)sscanf(&argv[arg][16], "%i", &waitKeyDelayInMilliSeconds);
			}
			else if (!_stricmp(argv[arg], "-pause")) {
				pauseBeforeExit = true;
			}
			else { printf("ERROR: invalid option: %s\n", argv[arg]); return -1; }
		}
		else break;
	}
	if (arg == argc) { show_usage(program, false); return -1; }
	int argCount = argc - arg - 2;
	fflush(stdout);

	CVxEngine engine;
	int errorCode = 0;
	try {
		// initialize engine
		if (engine.Initialize(argCount, defaultTargetAffinity, defaultTargetInfo, enableScheduleGraph, disableVirtual) < 0) throw - 1;
		if (doSetGraphOptimizerFlags) {
			engine.SetGraphOptimizerFlags(graphOptimizerFlags);
		}
		engine.SetConfigOptions(verbose, discardCompareErrors, enableDumpProfile, enableDumpGDF, waitKeyDelayInMilliSeconds);
		engine.SetFrameCountOptions(enableMultiFrameProcessing, framesEofRequested, frameCountSpecified, frameStart, frameEnd);
		fflush(stdout);
		// pass parameters to the engine: note that shell takes no extra parameters whereas node and file take extra parameter
		int argParamOffset = (!_stricmp(argv[arg], "shell")) ? 1 : 2;
		for (int i = 0, j = 0; i < argCount; i++) {
			char * param = argv[arg + argParamOffset + i];
			if (engine.SetParameter(j++, param) < 0)
				throw -1;
		}
		fflush(stdout);
		// get full GDF text
		char * fullText = nullptr;
		if (!_stricmp(argv[arg], "file")) {
			if ((arg+1) == argc)
				ReportError("ERROR: missing file name on command-line (see help for details)\n");
			arg++;
			const char * fileName = RootDirUpdated(argv[arg]);
			size_t size = strlen("include") + 1 + strlen(fileName) + 1;
			fullText = new char[size];
			sprintf(fullText, "include %s", fileName);
		}
		else if (!_stricmp(argv[arg], "node")) {
			if ((arg + 1) == argc)
				ReportError("ERROR: missing kernel name on command-line (see help for details)\n");
			int paramCount = argc - arg - 2;
			arg++;
			size_t size = strlen("node") + 1 + strlen(argv[arg]) + paramCount*6 + 1;
			fullText = new char[size];
			sprintf(fullText, "node %s", argv[arg]);
			for (int i = 0, j = 0; i < paramCount; i++)
				sprintf(fullText + strlen(fullText), " $%d", j++ + 1);
		}
		else if (!_stricmp(argv[arg], "shell")) {
			// nothing to do
		}
		else {
			printf("ERROR: invalid command: %s (see help for details)\n", argv[arg]);
			throw -1;
		}

		if (fullText) {
			// process the GDF
			if (engine.BuildAndProcessGraph(0, fullText, false) < 0)
				throw - 1;
			delete[] fullText;
		}
		else {
			// run shell
			if (engine.Shell(0) < 0)
				throw - 1;
		}
		fflush(stdout);

		if (engine.Shutdown() < 0) throw -1;
		fflush(stdout);
	}
	catch (int errorCode_) {
		fflush(stdout);
		engine.DisableWaitForKeyPress();
		errorCode = errorCode_;
	}
	if (pauseBeforeExit) {
		fflush(stdout);
		printf("Press ENTER to exit ...\n");
		while (getchar() != '\n')
			;
	}
	return errorCode;
}
コード例 #6
0
ファイル: vxMatrix.cpp プロジェクト: Badiboy/amdovx-core
int CVxParamMatrix::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
	// save reference object and get object attributes
	m_vxObjRef = ref;
	m_matrix = (vx_matrix)m_vxObjRef;
	ERROR_CHECK(vxQueryMatrix(m_matrix, VX_MATRIX_ATTRIBUTE_TYPE, &m_data_type, sizeof(m_data_type)));
	ERROR_CHECK(vxQueryMatrix(m_matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &m_columns, sizeof(m_columns)));
	ERROR_CHECK(vxQueryMatrix(m_matrix, VX_MATRIX_ATTRIBUTE_ROWS, &m_rows, sizeof(m_rows)));
	ERROR_CHECK(vxQueryMatrix(m_matrix, VX_MATRIX_ATTRIBUTE_SIZE, &m_size, sizeof(m_size)));

	// process I/O parameters
	if (*io_params == ':') io_params++;
	while (*io_params) {
		char ioType[64], fileName[256];
		io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
		if (!_stricmp(ioType, "read"))
		{ // read request syntax: read,<fileName>[,ascii|binary]
			m_fileNameRead.assign(RootDirUpdated(fileName));
			m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
			m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_readFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_readFileIsBinary = true;
				}
				else ReportError("ERROR: invalid matrix read option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "write"))
		{ // write request syntax: write,<fileName>[,ascii|binary]
			m_fileNameWrite.assign(RootDirUpdated(fileName));
			m_writeFileIsBinary = (m_fileNameWrite.find(".txt") != m_fileNameWrite.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_writeFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_writeFileIsBinary = true;
				}
				else ReportError("ERROR: invalid matrix write option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "compare"))
		{ // compare request syntax: compare,<fileName>[,ascii|binary][,err{<tolerance>}]
			m_fileNameCompare.assign(RootDirUpdated(fileName));
			m_compareFileIsBinary = (m_fileNameCompare.find(".txt") != m_fileNameCompare.npos) ? false : true;
			while (*io_params == ',') {
				char option[64];
				io_params = ScanParameters(io_params, ",ascii|binary|err{<tolerance>}", ",s", option);
				if (!_stricmp(option, "ascii")) {
					m_compareFileIsBinary = false;
				}
				else if (!_stricmp(option, "binary")) {
					m_compareFileIsBinary = true;
				}
				else if (!_strnicmp(option, "err{", 4)) {
					ScanParameters(&option[3], "{<tolerance>}", "{f}", &m_errTolerance);
				}
				else ReportError("ERROR: invalid matrix compare option: %s\n", option);
			}
		}
		else if (!_stricmp(ioType, "init"))
		{ // write request syntax: init,{<value1>;<value2>;...<valueN>}
			NULLPTR_CHECK(m_bufForAccess = new vx_uint8[m_size]);
			vx_size index = 0; char fmt[3] = { '{', (m_data_type == VX_TYPE_FLOAT32) ? 'f' : 'd', 0 };
			for (const char * s = fileName; *s && index < (m_columns * m_rows); fmt[0] = ';', index++) {
				if (m_data_type == VX_TYPE_INT32 || m_data_type == VX_TYPE_UINT8) {
					vx_uint32 value;
					s = ScanParameters(s, "<value>", fmt, &value);
					if (m_data_type == VX_TYPE_UINT8) ((vx_uint8 *)m_bufForAccess)[index] = (vx_uint8)value;
					else ((vx_int32 *)m_bufForAccess)[index] = value;
				}
				else if (m_data_type == VX_TYPE_FLOAT32) {
					s = ScanParameters(s, "<value>", fmt, &((vx_float32 *)m_bufForAccess)[index]);
				}
				else ReportError("ERROR: matrix init option not support for data_type of %s\n", GetVxObjectName());
			}
			if (index < (m_columns * m_rows)) ReportError("ERROR: matrix init have too few values: %s\n", fileName);
			ERROR_CHECK(vxWriteMatrix(m_matrix, m_bufForAccess));
		}
		else if (!_stricmp(ioType, "directive") && !_stricmp(fileName, "readonly")) {
			ERROR_CHECK(vxDirective((vx_reference)m_matrix, VX_DIRECTIVE_AMD_READ_ONLY));
		}
		else if (!_stricmp(ioType, "ui") && !_strnicmp(fileName, "f", 1) && m_data_type == VX_TYPE_FLOAT32 && m_columns == 3 && m_rows == 3) {
			int id = 0;
			float valueR = 200.0f, valueInc = 0.5f;
			if (sscanf(&fileName[1], "%d,%g,%g", &id, &valueR, &valueInc) != 3) {
				printf("ERROR: invalid matrix UI configuration '%s'\n", fileName);
				return -1;
			}
			id--;
			GuiTrackBarInitializeMatrix((vx_reference)m_matrix, id, valueR, valueInc);
			GuiTrackBarProcessKey(0); // just initialize the matrix
		}
		else ReportError("ERROR: invalid matrix operation: %s\n", ioType);
		if (*io_params == ':') io_params++;
		else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
	}

	return 0;
}