343 struct PEAK_PRODUCER_LIBRARY;
347 struct PEAK_SYSTEM_DESCRIPTOR;
355 struct PEAK_INTERFACE_DESCRIPTOR;
359 struct PEAK_INTERFACE;
363 struct PEAK_DEVICE_DESCRIPTOR;
371 struct PEAK_REMOTE_DEVICE;
375 struct PEAK_DATA_STREAM_DESCRIPTOR;
379 struct PEAK_DATA_STREAM;
387 struct PEAK_BUFFER_CHUNK;
391 struct PEAK_BUFFER_PART;
395 struct PEAK_MODULE_DESCRIPTOR;
403 struct PEAK_NODE_MAP;
411 struct PEAK_INTEGER_NODE;
415 struct PEAK_BOOLEAN_NODE;
419 struct PEAK_COMMAND_NODE;
423 struct PEAK_FLOAT_NODE;
427 struct PEAK_STRING_NODE;
431 struct PEAK_REGISTER_NODE;
435 struct PEAK_CATEGORY_NODE;
439 struct PEAK_ENUMERATION_NODE;
443 struct PEAK_ENUMERATION_ENTRY_NODE;
451 struct PEAK_PORT_URL;
455 struct PEAK_EVENT_SUPPORTING_MODULE;
459 struct PEAK_EVENT_CONTROLLER;
467 struct PEAK_FIRMWARE_UPDATER;
471 struct PEAK_FIRMWARE_UPDATE_INFORMATION;
475 struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER;
482 PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface,
void* context);
485 const char* lostInterfaceId,
size_t lostInterfaceIdSize,
void* context);
493 PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice,
void* context);
496 const char* lostDeviceId,
size_t lostDeviceIdSize,
void* context);
512 const PEAK_DEVICE_INFORMATION_ROLE* changedRoles,
size_t changedRolesSize,
void* context);
519 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, uint32_t estimatedDuration_ms,
525 uint32_t estimatedDuration_ms,
const char* description,
size_t descriptionSize,
void* context);
530 PEAK_FIRMWARE_UPDATE_STEP updateStep,
double progressPercentage,
void* context);
536 PEAK_FIRMWARE_UPDATE_STEP updateStep,
void* context);
545 const char* errorDescription,
size_t errorDescriptionSize,
void* context);
550 #define PEAK_C_API PEAK_PUBLIC PEAK_RETURN_CODE PEAK_CALL_CONV 552 #ifndef PEAK_DYNAMIC_LOADING 656 PEAK_RETURN_CODE* lastErrorCode,
char* lastErrorDescription,
size_t* lastErrorDescriptionSize);
716 const char* ctiPath,
size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
733 PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle,
char* key,
size_t* keySize);
748 PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE* systemDescriptorHandle);
776 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
793 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* key,
size_t* keySize);
812 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
829 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* displayName,
size_t* displayNameSize);
846 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* vendorName,
size_t* vendorNameSize);
863 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* modelName,
size_t* modelNameSize);
880 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* version,
size_t* versionSize);
897 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* tlType,
size_t* tlTypeSize);
914 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* ctiFileName,
size_t* ctiFileNameSize);
931 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle,
char* ctiFullPath,
size_t* ctiFullPathSize);
946 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t* gentlVersionMajor);
961 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t* gentlVersionMinor);
976 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING* characterEncoding);
991 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
1006 PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE* systemHandle);
1036 PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
1071 PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1104 PEAK_SYSTEM_HANDLE systemHandle,
char* displayName,
size_t* displayNameSize);
1121 PEAK_SYSTEM_HANDLE systemHandle,
char* vendorName,
size_t* vendorNameSize);
1186 PEAK_SYSTEM_HANDLE systemHandle,
char* ctiFileName,
size_t* ctiFileNameSize);
1203 PEAK_SYSTEM_HANDLE systemHandle,
char* ctiFullPath,
size_t* ctiFullPathSize);
1246 PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING* characterEncoding);
1261 PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE* producerLibraryHandle);
1305 PEAK_SYSTEM_HANDLE systemHandle,
size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE* interfaceDescriptorHandle);
1323 PEAK_INTERFACE_FOUND_CALLBACK_HANDLE* callbackHandle);
1337 PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle);
1355 PEAK_INTERFACE_LOST_CALLBACK_HANDLE* callbackHandle);
1369 PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle);
1397 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
1398 PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
1415 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
char* key,
size_t* keySize);
1434 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1451 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
char* displayName,
size_t* displayNameSize);
1468 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle,
char* tlType,
size_t* tlTypeSize);
1483 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE* systemHandle);
1498 PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
1528 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
1563 int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1596 PEAK_INTERFACE_HANDLE interfaceHandle,
char* displayName,
size_t* displayNameSize);
1627 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE* systemHandle);
1671 PEAK_INTERFACE_HANDLE interfaceHandle,
size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE* deviceDescriptorHandle);
1689 PEAK_DEVICE_FOUND_CALLBACK_HANDLE* callbackHandle);
1703 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle);
1734 PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle);
1762 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
1779 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* key,
size_t* keySize);
1798 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
1815 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* displayName,
size_t* displayNameSize);
1832 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* vendorName,
size_t* vendorNameSize);
1849 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* modelName,
size_t* modelNameSize);
1866 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* version,
size_t* versionSize);
1883 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* tlType,
size_t* tlTypeSize);
1900 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* userDefinedName,
size_t* userDefinedNameSize);
1917 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
char* serialNumber,
size_t* serialNumberSize);
1932 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS* accessStatus);
1947 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t* timestampTickFrequency);
1962 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8* isOpenable);
1980 PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8* isOpenable);
1996 PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE* deviceHandle);
2011 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
2026 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t* monitoringUpdateInterval_ms);
2040 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms);
2056 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole,
2057 PEAK_BOOL8* isInformationRoleMonitored);
2071 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole);
2085 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole);
2102 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
2118 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
2149 PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
2184 PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
2217 PEAK_DEVICE_HANDLE deviceHandle,
char* displayName,
size_t* displayNameSize);
2234 PEAK_DEVICE_HANDLE deviceHandle,
char* vendorName,
size_t* vendorNameSize);
2299 PEAK_DEVICE_HANDLE deviceHandle,
char* userDefinedName,
size_t* userDefinedNameSize);
2316 PEAK_DEVICE_HANDLE deviceHandle,
char* serialNumber,
size_t* serialNumberSize);
2331 PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS* accessStatus);
2346 PEAK_DEVICE_HANDLE deviceHandle, uint64_t* timestampTickFrequency);
2361 PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE* interfaceHandle);
2376 PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE* remoteDeviceHandle);
2407 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE* dataStreamDescriptorHandle);
2435 PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE* moduleHandle);
2450 PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE* deviceHandle);
2466 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle,
2467 PEAK_MODULE_DESCRIPTOR_HANDLE* moduleDescriptorHandle);
2484 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle,
char* key,
size_t* keySize);
2499 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE* deviceHandle);
2514 PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE* dataStreamHandle);
2530 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE* moduleHandle);
2545 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
2580 int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
2613 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
char* tlType,
size_t* tlTypeSize);
2628 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersAnnouncedMinRequired);
2643 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersAnnounced);
2658 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersQueued);
2673 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numBuffersAwaitDelivery);
2688 PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numBuffersDelivered);
2703 PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t* numBuffersStarted);
2732 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* numChunksPerBufferMax);
2747 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t* bufferAlignment);
2776 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8* definesPayloadSize);
2805 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE* deviceHandle);
2828 PEAK_BUFFER_HANDLE* bufferHandle);
2845 PEAK_DATA_STREAM_HANDLE dataStreamHandle,
size_t bufferSize,
void* userPtr, PEAK_BUFFER_HANDLE* bufferHandle);
2859 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle);
2873 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle);
2891 PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE* bufferHandle);
2920 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode);
2934 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode);
2950 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire);
2964 PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode);
3006 PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE* eventSupportingModuleHandle);
3025 PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
3098 PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE* payloadType);
3127 PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE* pixelFormatNamespace);
3142 PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS* pixelEndianness);
3227 PEAK_BUFFER_HANDLE bufferHandle,
size_t* deliveredChunkPayloadSize);
3496 PEAK_BUFFER_HANDLE bufferHandle,
size_t index, PEAK_BUFFER_CHUNK_HANDLE* bufferChunkHandle);
3539 PEAK_BUFFER_HANDLE bufferHandle,
size_t index, PEAK_BUFFER_PART_HANDLE* bufferPartHandle);
3597 PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE* bufferHandle);
3630 int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
3715 PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t* formatNamespace);
3800 PEAK_BUFFER_PART_HANDLE bufferPartHandle,
size_t* deliveredImageHeight);
3815 PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE* bufferHandle);
3846 PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle,
char*
id,
size_t* idSize);
3878 PEAK_MODULE_HANDLE moduleHandle,
size_t index, PEAK_NODE_MAP_HANDLE* nodeMapHandle);
3910 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* nodeName,
size_t nodeNameSize, PEAK_BOOL8* hasNode);
3928 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* nodeName,
size_t nodeNameSize, PEAK_NODE_HANDLE* nodeHandle);
3984 PEAK_NODE_MAP_HANDLE nodeMapHandle,
size_t index, PEAK_NODE_HANDLE* nodeHandle);
4000 PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8* hasSupportedChunks);
4017 PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle);
4033 PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8* hasSupportedData);
4069 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* filePath,
size_t filePathSize);
4088 PEAK_NODE_MAP_HANDLE nodeMapHandle,
const char* filePath,
size_t filePathSize);
4137 PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE* integerNodeHandle);
4153 PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE* booleanNodeHandle);
4169 PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE* commandNodeHandle);
4215 PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE* registerNodeHandle);
4231 PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE* categoryNodeHandle);
4247 PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE* enumerationNodeHandle);
4263 PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
4366 PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8* isAccessStatusCacheable);
4515 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* invalidatedNodeHandle);
4546 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* invalidatedNodeHandle);
4564 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* invalidatingNodeHandle);
4595 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* invalidatingNodeHandle);
4613 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* selectedNodeHandle);
4644 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* selectedNodeHandle);
4662 PEAK_NODE_HANDLE nodeHandle,
const char* name,
size_t nameSize, PEAK_NODE_HANDLE* selectingNodeHandle);
4693 PEAK_NODE_HANDLE nodeHandle,
size_t index, PEAK_NODE_HANDLE* selectingNodeHandle);
4711 PEAK_NODE_CHANGED_CALLBACK_HANDLE* callbackHandle);
4725 PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle);
4741 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
4798 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE* incrementType);
4815 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t* validValues,
size_t* validValuesSize);
4830 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION* representation);
4861 PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t* value);
4890 PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
4906 PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8* value);
4935 PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5061 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE* incrementType);
5078 PEAK_FLOAT_NODE_HANDLE floatNodeHandle,
double* validValues,
size_t* validValuesSize);
5093 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION* representation);
5123 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION* displayNotation);
5138 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t* displayPrecision);
5153 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8* hasConstantIncrement);
5169 PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy,
double* value);
5228 PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy,
char* value,
size_t* valueSize);
5243 PEAK_STRING_NODE_HANDLE stringNodeHandle,
const char* value,
size_t valueSize);
5259 PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5304 PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t* bytesToRead,
size_t bytesToReadSize);
5320 PEAK_REGISTER_NODE_HANDLE registerNodeHandle,
const uint8_t* bytesToWrite,
size_t bytesToWriteSize);
5336 PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5367 PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle,
size_t index, PEAK_NODE_HANDLE* nodeHandle);
5383 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5399 PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5414 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle);
5431 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
const char* symbolicValue,
size_t symbolicValueSize);
5446 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value);
5464 const char* symbolicValue,
size_t symbolicValueSize,
5465 PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5482 int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5497 PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle,
size_t* numEntries);
5514 PEAK_ENUMERATION_ENTRY_NODE_HANDLE* enumerationEntryNodeHandle);
5530 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE* nodeHandle);
5545 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8* isSelfClearing);
5562 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle,
char* symbolicValue,
size_t* symbolicValueSize);
5577 PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t* value);
5597 PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
5797 PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t* bytesToRead,
size_t bytesToReadSize);
5816 PEAK_PORT_HANDLE portHandle, uint64_t address,
const uint8_t* bytesToWrite,
size_t bytesToWriteSize);
5866 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
5927 PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t* fileRegisterAddress);
5957 PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t* fileSha1Hash,
size_t* fileSha1HashSize);
6000 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileVersionSubminor);
6015 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileSchemaVersionMajor);
6030 PEAK_PORT_URL_HANDLE portUrlHandle, int32_t* fileSchemaVersionMinor);
6061 PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType,
6062 PEAK_EVENT_CONTROLLER_HANDLE* eventControllerHandle);
6082 int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
6097 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
size_t* numEventsInQueue);
6112 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t* numEventsFired);
6127 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
size_t* eventMaxSize);
6142 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle,
size_t* eventDataMaxSize);
6157 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE* controlledEventType);
6173 PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE* eventHandle);
6232 PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t* infoDataType, uint8_t* info,
size_t* infoSize);
6340 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
const char* gufPath,
size_t gufPathSize);
6357 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
const char* gufPath,
size_t gufPathSize,
6358 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle);
6373 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
size_t* numFirmwareUpdateInformation);
6390 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle,
size_t index,
6391 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE* firmwareUpdateInformationHandle);
6409 PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
6410 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6411 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);
6430 PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle,
6431 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6432 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6433 uint64_t deviceResetDiscoveryTimeout_ms);
6461 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8* isValid);
6478 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* fileName,
size_t* fileNameSize);
6495 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* description,
6496 size_t* descriptionSize);
6513 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* version,
size_t* versionSize);
6530 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* versionExtractionPattern,
6531 size_t* versionExtractionPatternSize);
6546 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6547 PEAK_FIRMWARE_UPDATE_VERSION_STYLE* versionStyle);
6564 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* releaseNotes,
6565 size_t* releaseNotesSize);
6582 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
char* releaseNotesUrl,
6583 size_t* releaseNotesUrlSize);
6598 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6599 PEAK_FIRMWARE_UPDATE_PERSISTENCE* userSetPersistence);
6614 PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle,
6615 PEAK_FIRMWARE_UPDATE_PERSISTENCE* sequencerSetPersistence);
6629 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE* firmwareUpdateProgressObserverHandle);
6646 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6648 PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE* callbackHandle);
6663 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6664 PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle);
6681 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6683 PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE* callbackHandle);
6698 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6699 PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle);
6717 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6734 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6752 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6754 PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE* callbackHandle);
6769 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6770 PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle);
6787 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6789 PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE* callbackHandle);
6804 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6805 PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle);
6822 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6824 PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE* callbackHandle);
6839 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle,
6840 PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle);
6853 PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle);
6865 #endif // !PEAK_DYNAMIC_LOADING PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Asks the given integer node for its increment.
PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Asks the given buffer for its delivered image height.
PEAK_C_API PEAK_DataStream_GetParentDevice(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Asks the given data stream for its parent device.
PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths()
Collects the paths to the CTIs installed on the system.
struct PEAK_FIRMWARE_UPDATER * PEAK_FIRMWARE_UPDATER_HANDLE
Definition: peak_backend.h:469
PEAK_C_API PEAK_Device_GetDisplayName(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Asks the given device for its display name.
Definition: peak_backend.h:111
Definition: peak_backend.h:260
PEAK_ENDIANNESS_t
Definition: peak_backend.h:149
PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Asks the given enumeration entry node whether it is self clearing.
Definition: peak_backend.h:329
PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given interface descriptor to a module descriptor.
PEAK_C_API PEAK_DataStream_RevokeBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Tells the given data stream to revoke the given buffer.
PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Asks the given node for its number of selected nodes.
int32_t PEAK_ACQUISITION_STOP_MODE
Definition: peak_backend.h:45
Definition: peak_backend.h:333
PEAK_C_API PEAK_Buffer_GetPayloadType(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Asks the given buffer for its payload type.
PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Asks the given buffer for its user pointer.
PEAK_C_API PEAK_Device_GetAccessStatus(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Asks the given device for its access status.
PEAK_EVENT_TYPE_t
Definition: peak_backend.h:158
PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given device to a module.
Definition: peak_backend.h:272
PEAK_C_API PEAK_System_GetCTIFullPath(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Asks the given system for its parent CTI's full path.
struct PEAK_PRODUCER_LIBRARY * PEAK_PRODUCER_LIBRARY_HANDLE
Definition: peak_backend.h:345
Definition: peak_backend.h:57
PEAK_C_API PEAK_FloatNode_GetDisplayNotation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Asks the given float node for its display notation.
PEAK_C_API PEAK_System_GetCharacterEncoding(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Asks the given system for its character encoding.
PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Asks the given port for its ID.
Definition: peak_backend.h:40
PEAK_C_API PEAK_System_GetCTIFileName(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Asks the given system for its parent CTI's file name.
PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Asks the given buffer part for its Y offset.
Definition: peak_backend.h:232
PEAK_C_API PEAK_RegisterNode_ToNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given register node to a node.
PEAK_ACQUISITION_STOP_MODE_t
Definition: peak_backend.h:38
Definition: peak_backend.h:322
Definition: peak_backend.h:321
PEAK_C_API PEAK_Device_GetParentInterface(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Asks the given device for its parent interface.
Definition: peak_backend.h:327
PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Asks the given buffer whether it has chunks.
Definition: peak_backend.h:318
int32_t PEAK_NODE_CACHING_MODE
Definition: peak_backend.h:217
PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Asks the given system descriptor for its parent CTI's full path.
PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Asks the given system descriptor for the minor component of its GenTL version.
Definition: peak_backend.h:69
Definition: peak_backend.h:284
PEAK_C_API PEAK_DataStream_AnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, void *buffer, size_t bufferSize, void *userPtr, PEAK_BUFFER_REVOCATION_CALLBACK revocationCallback, void *callbackContext, PEAK_BUFFER_HANDLE *bufferHandle)
Announces the given buffer at the given data stream.
PEAK_C_API PEAK_EnumerationEntryNode_GetValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Asks the given enumeration entry node for its value.
PEAK_C_API PEAK_CategoryNode_GetSubNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Asks the given category node for the sub node with the given index.
PEAK_C_API PEAK_Buffer_GetInfo(PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given buffer for an information based on a specific command.
PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Unregisters the interface-lost callback with the given handle from the given system.
int32_t PEAK_PORT_URL_SCHEME
Definition: peak_backend.h:312
PEAK_C_API PEAK_Node_FindInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Tells the given node to find an invalidating node with the given name.
Definition: peak_backend.h:71
Definition: peak_backend.h:214
PEAK_C_API PEAK_System_GetParentLibrary(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Asks the given system for its parent library.
PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Asks the given device for its model name.
Definition: peak_backend.h:262
PEAK_C_API PEAK_SystemDescriptor_GetTLType(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Asks the given system descriptor for its TL type.
PEAK_C_API PEAK_FloatNode_GetRepresentation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Asks the given float node for its representation.
PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Asks the given node for its caching mode.
PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Asks the given node whether it is deprecated.
Definition: peak_backend.h:109
PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Asks the given buffer for its height.
const uint64_t PEAK_INFINITE_NUMBER
The constant defining an infinite number of buffers.
Definition: peak_backend.h:338
Definition: peak_backend.h:133
int32_t PEAK_ACQUISITION_START_MODE
Definition: peak_backend.h:35
PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Asks the given buffer part for its X offset.
PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Asks the given integer node for its minimum.
Definition: peak_backend.h:185
PEAK_C_API PEAK_FloatNode_GetIncrementType(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Asks the given float node for its increment type.
Definition: peak_backend.h:138
PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Destroys the given data stream.
PEAK_C_API PEAK_EventController_WaitForEvent(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE *eventHandle)
Tells the given event controller to wait for an event with the given timeout.
PEAK_C_API PEAK_BooleanNode_GetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8 *value)
Asks the given boolean node for its value.
PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Asks the given port URL for its file SHA1 hash.
PEAK_C_API PEAK_RegisterNode_Write(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Tells the given register node to write the given bytes.
PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given buffer to a module.
PEAK_C_API PEAK_Node_FindSelectingNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectingNodeHandle)
Tells the given node to find a selecting node with the given name.
PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Asks the given float node for its minimum.
struct PEAK_PORT_URL * PEAK_PORT_URL_HANDLE
Definition: peak_backend.h:453
PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Asks the given device descriptor for its parent interface.
PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Asks the given device descriptor for its vendor name.
PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Asks the given port for its version.
int8_t PEAK_BOOL8
Definition: peak_backend.h:26
Definition: peak_backend.h:50
Definition: peak_backend.h:320
PEAK_C_API PEAK_Library_Close()
Closes the IDS peak API library and cleans up any resources that are still in use.
PEAK_C_API PEAK_DeviceDescriptor_OpenDevice(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE *deviceHandle)
Opens the device being associated with the given interface descriptor for the given access type...
PEAK_C_API PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t index, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE *firmwareUpdateInformationHandle)
Asks the given firmware updater for the update information with the given index.
PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Asks the given data stream for its number of queued buffers.
PEAK_C_API PEAK_StringNode_GetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, char *value, size_t *valueSize)
Asks the given string node for its value.
PEAK_C_API PEAK_IntegerNode_GetValidValues(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Asks the given integer node for its valid values.
PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Asks the given system descriptor for its character encoding.
PEAK_C_API PEAK_IntegerNode_ToNode(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given integer node to a node.
PEAK_C_API PEAK_Interface_RegisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK callback, void *callbackContext, PEAK_DEVICE_FOUND_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a found device at the given interface.
Definition: peak_backend.h:332
int32_t PEAK_DEVICE_INFORMATION_ROLE
Definition: peak_backend.h:146
Definition: peak_backend.h:256
PEAK_C_API PEAK_DataStream_ToModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given data stream to a module.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Asks the given firmware update information for its version style.
PEAK_C_API PEAK_Interface_RegisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LOST_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a lost device at the given interface.
PEAK_C_API PEAK_EnumerationNode_GetNumEntries(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Asks the given enumeration node for its number of entries.
Definition: peak_backend.h:287
PEAK_C_API PEAK_DeviceDescriptor_IsInformationRoleMonitored(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole, PEAK_BOOL8 *isInformationRoleMonitored)
Asks the given device descriptor whether the given information role is monitored. ...
Definition: peak_backend.h:231
PEAK_BUFFER_PART_TYPE_t
Definition: peak_backend.h:48
Definition: peak_backend.h:74
Definition: peak_backend.h:277
Definition: peak_backend.h:72
PEAK_C_API PEAK_System_RegisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_LOST_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a lost interface at the given system.
PEAK_C_API PEAK_Module_GetNodeMap(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Asks the given module for the node map with the given index.
PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Asks the given interface for its TL type.
PEAK_C_API PEAK_Node_ToEnumerationEntryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Casts the given node to an enumeration entry node.
PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Asks the given port URL for its parent port.
Definition: peak_backend.h:213
struct PEAK_INTERFACE_DESCRIPTOR * PEAK_INTERFACE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:357
PEAK_C_API PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, uint64_t deviceResetDiscoveryTimeout_ms)
Tells the given firmware updater to update the given device with the given update information...
PEAK_C_API PEAK_DataStream_QueueBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Tells the given data stream to queue the given buffer.
PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Asks the given firmware updater for its number of update information.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a progress change within an update step at the given firmware update p...
PEAK_C_API PEAK_BufferPart_GetParentBuffer(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Asks the given buffer part for its parent buffer.
Definition: peak_backend.h:308
PEAK_C_API PEAK_Interface_GetDisplayName(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Asks the given interface for its display name.
PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Destroys the given buffer part.
PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Asks the given device for its key.
PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Asks the given data stream for its number of started buffers.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a finished update at the given firmware update progress observer...
int32_t PEAK_NODE_TYPE
Definition: peak_backend.h:279
PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Asks the given device descriptor for its access status.
Definition: peak_backend.h:181
PEAK_C_API PEAK_IntegerNode_GetIncrementType(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Asks the given integer node for its increment type.
PEAK_C_API PEAK_EventController_GetEventMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Asks the event controller for the maximum size of an event.
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Tells the given enumeration node to set its current entry by the given symbolic value.
Definition: peak_backend.h:53
PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Asks the given node whether it is a feature, i.e. it can be reached via category nodes from a categor...
Definition: peak_backend.h:137
Definition: peak_backend.h:270
PEAK_C_API PEAK_System_GetVendorName(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Asks the given system for its vendor name.
PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Asks the given integer node for its unit.
PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Asks the given system descriptor for its parent CTI's file name.
PEAK_PORT_URL_SCHEME_t
Definition: peak_backend.h:304
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Tells the given enumeration node to set its current entry to the given entry.
struct PEAK_INTEGER_NODE * PEAK_INTEGER_NODE_HANDLE
Definition: peak_backend.h:413
Definition: peak_backend.h:307
struct PEAK_EVENT_SUPPORTING_MODULE * PEAK_EVENT_SUPPORTING_MODULE_HANDLE
Definition: peak_backend.h:457
Definition: peak_backend.h:41
void(PEAK_CALL_CONV * PEAK_DEVICE_FOUND_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void *context)
Definition: peak_backend.h:492
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle)
Unregisters the update started callback with the given handle from the given firmware update progress...
PEAK_NODE_NAMESPACE_t
Definition: peak_backend.h:246
PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Asks the given port for its model name.
PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Asks the given buffer for its timestamp in nanoseconds.
Definition: peak_backend.h:310
PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Asks the given data stream for its number of announced buffers.
PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Asks the given node whether it is streamable.
PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Asks the given buffer for its chunk layout ID.
PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Asks the given node for its polling time.
Definition: peak_backend.h:261
struct PEAK_CATEGORY_NODE * PEAK_CATEGORY_NODE_HANDLE
Definition: peak_backend.h:437
PEAK_C_API PEAK_Interface_GetInfo(PEAK_INTERFACE_HANDLE interfaceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given interface for an information based on a specific command.
Definition: peak_backend.h:323
PEAK_C_API PEAK_ProducerLibrary_GetSystem(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Asks the given producer library for its system descriptor.
PEAK_NODE_DISPLAY_NOTATION_t
Definition: peak_backend.h:228
PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Asks the given interface for its key.
int32_t PEAK_NODE_INCREMENT_TYPE
Definition: peak_backend.h:243
PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Tells the given data stream to kill a wait for a finished buffer.
PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Asks the given integer node for its maximum.
PEAK_C_API PEAK_DeviceDescriptor_GetVersion(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Asks the given device descriptor for its version.
int32_t PEAK_NODE_VISIBILITY
Definition: peak_backend.h:289
PEAK_C_API PEAK_Node_FindInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Tells the given node to find an invalidated node with the given name.
Definition: peak_backend.h:55
Definition: peak_backend.h:113
PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Opens the interface being associated with the given interface descriptor.
PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Asks the given node map for its number of nodes.
PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Asks the given buffer for its pixel format namespace.
PEAK_C_API PEAK_Node_ToRegisterNode(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Casts the given node to a register node.
PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t *numCtiPaths)
Asks for the number of CTI paths.
PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Asks the given node for its number of selecting nodes.
Definition: peak_backend.h:33
PEAK_C_API PEAK_SystemDescriptor_GetInfo(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given system descriptor for an information based on a specific command.
Definition: peak_backend.h:184
PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Asks the given buffer for its expected data size.
PEAK_C_API PEAK_Node_ToCommandNode(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Casts the given node to a command node.
struct PEAK_EVENT_CONTROLLER * PEAK_EVENT_CONTROLLER_HANDLE
Definition: peak_backend.h:461
Definition: peak_backend.h:112
PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Tells the given node map to poll its nodes.
Definition: peak_backend.h:223
PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given interface to a module.
int32_t PEAK_RETURN_CODE
Definition: peak_backend.h:335
Definition: peak_backend.h:43
PEAK_C_API PEAK_DeviceDescriptor_GetTLType(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Asks the given device descriptor for its TL type.
PEAK_C_API PEAK_Device_GetInfo(PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given device for an information based on a specific command.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Asks the given firmware update information for its release notes.
PEAK_C_API PEAK_Device_GetUserDefinedName(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Asks the given device for its user-defined name.
PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Asks the given category node for its number of sub nodes.
PEAK_C_API PEAK_SystemDescriptor_GetVersion(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Asks the given system descriptor for its version.
PEAK_NODE_CACHE_USE_POLICY_t
Definition: peak_backend.h:220
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the update step progress changed callback with the given handle from the given firmware u...
PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Asks the given system for its TL type.
void(PEAK_CALL_CONV * PEAK_INTERFACE_FOUND_CALLBACK)(PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface, void *context)
Definition: peak_backend.h:481
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Creates a firmware update progress observer.
Definition: peak_backend.h:296
PEAK_C_API PEAK_EnumerationNode_ToNode(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given enumeration node to a node.
PEAK_NODE_REPRESENTATION_t
Definition: peak_backend.h:254
PEAK_C_API PEAK_DataStreamDescriptor_GetKey(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Asks the given data stream descriptor for its key.
PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Asks the given register node for its length.
PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Asks the given system descriptor for its parent library.
Definition: peak_backend.h:139
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void *context)
Definition: peak_backend.h:529
PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Asks the given buffer for its delivered chunk payload size.
PEAK_C_API PEAK_DataStream_AllocAndAnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t bufferSize, void *userPtr, PEAK_BUFFER_HANDLE *bufferHandle)
Tells the given data stream to allocate and announce a buffer with the given size.
PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Waits (blocking) until the previously executed command is finished, i.e. PEAK_CommandNode_GetIsDone()...
Definition: peak_backend.h:164
PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Asks the given data stream whether it is grabbing.
struct PEAK_NODE * PEAK_NODE_HANDLE
Definition: peak_backend.h:409
Definition: peak_backend.h:31
PEAK_C_API PEAK_Node_FindSelectedNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectedNodeHandle)
Tells the given node to find a selected node with the given name.
PEAK_C_API PEAK_Buffer_GetPart(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Asks the given buffer for the part with the given index.
PEAK_C_API PEAK_Node_RegisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK callback, void *callbackContext, PEAK_NODE_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a change at the given node.
PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Asks the given device for its version.
Definition: peak_backend.h:54
PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Asks the given remote device for its local device.
Definition: peak_backend.h:153
PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Tells the given event controller to flush all events in queue.
PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given system descriptor to a module descriptor.
Definition: peak_backend.h:70
PEAK_C_API PEAK_Library_GetLastError(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Queries the last error.
PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Asks the given event for its type.
PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Destroys the given firmware updater.
PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Asks the given interface descriptor for its display name.
PEAK_C_API PEAK_ProducerLibrary_GetKey(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Asks the given producer library for its key.
int32_t PEAK_NODE_DISPLAY_NOTATION
Definition: peak_backend.h:234
PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Asks the given port URL for the major component of its file schema version.
PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Asks the given buffer for its timestamp in ticks.
Definition: peak_backend.h:142
PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Updates event information in the node map.
PEAK_C_API PEAK_Node_GetSelectingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Asks the given node for the selecting node with the given index.
Definition: peak_backend.h:110
Definition: peak_backend.h:202
Definition: peak_backend.h:80
int32_t PEAK_NODE_NAMESPACE
Definition: peak_backend.h:251
PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Asks the given firmware update information for its description.
PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Asks the given node for its number of invalidated nodes.
Definition: peak_backend.h:326
PEAK_C_API PEAK_System_RegisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a found interface at the given system.
Definition: peak_backend.h:95
PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE
Definition: peak_backend.h:542
Definition: peak_backend.h:52
PEAK_C_API PEAK_PortURL_GetInfo(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given port URL for an information based on a specific command.
PEAK_C_API PEAK_DataStream_WaitForFinishedBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE *bufferHandle)
Tells the given data stream to wait for a finished buffer with the given timeout. ...
int32_t PEAK_CHARACTER_ENCODING
Definition: peak_backend.h:90
PEAK_C_API PEAK_EventSupportingModule_EnableEvents(PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType, PEAK_EVENT_CONTROLLER_HANDLE *eventControllerHandle)
Tells the given event-supporting module to enable events of the given type.
PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Asks the given float node for its maximum.
int32_t PEAK_DEVICE_ACCESS_TYPE
Definition: peak_backend.h:128
PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Asks the given node for its namespace.
PEAK_DEVICE_ACCESS_STATUS_t
Definition: peak_backend.h:106
Definition: peak_backend.h:134
int32_t PEAK_DATA_STREAM_FLUSH_MODE
Definition: peak_backend.h:103
PEAK_C_API PEAK_ProducerLibrary_Construct(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Creates a producer library.
int32_t PEAK_ENDIANNESS
Definition: peak_backend.h:155
Definition: peak_backend.h:162
Definition: peak_backend.h:77
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a failed update at the given firmware update progress observer...
PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Tells the given boolean node to set the given value.
PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Asks the given port URL for its scheme.
Definition: peak_backend.h:136
PEAK_NODE_INCREMENT_TYPE_t
Definition: peak_backend.h:237
int32_t PEAK_EVENT_TYPE
Definition: peak_backend.h:168
PEAK_C_API PEAK_Node_ToEnumerationNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Casts the given node to an enumeration node.
PEAK_C_API PEAK_DataStream_GetTLType(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Asks the given data stream for its TL type.
struct PEAK_NODE_MAP * PEAK_NODE_MAP_HANDLE
Definition: peak_backend.h:405
PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Asks the given buffer part for its height.
PEAK_C_API PEAK_SystemDescriptor_OpenSystem(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Opens the system being associated with the given system descriptor.
PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Unregisters the interface-found callback with the given handle from the given system.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Asks the given firmware update information for its file name.
PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Checks if the buffer contains chunks corresponding to the node map.
PEAK_FIRMWARE_UPDATE_PERSISTENCE_t
Definition: peak_backend.h:171
PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Asks the given data stream for its number of delivered buffers.
Definition: peak_backend.h:324
PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Asks the given system for its key.
struct PEAK_MODULE_DESCRIPTOR * PEAK_MODULE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:397
PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Asks the given node for its display name.
struct PEAK_ENUMERATION_ENTRY_NODE * PEAK_ENUMERATION_ENTRY_NODE_HANDLE
Definition: peak_backend.h:445
PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Asks the given port for the URL with the given index.
PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Asks the given port for its number of URLs.
PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given system to a module.
Definition: peak_backend.h:286
PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Asks the given buffer chunk for its base pointer.
PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Asks the given buffer for its Y offset.
PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given device descriptor to a module descriptor.
PEAK_C_API PEAK_DataStream_Flush(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Tells the given data stream to flush its queues using the given mode.
Definition: peak_backend.h:51
PEAK_C_API PEAK_Device_GetRemoteDevice(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Asks the given device for its remote device.
PEAK_DEVICE_FOUND_CALLBACK * PEAK_DEVICE_FOUND_CALLBACK_HANDLE
Definition: peak_backend.h:498
PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Asks the given interface descriptor for its TL type.
PEAK_C_API PEAK_Port_Write(PEAK_PORT_HANDLE portHandle, uint64_t address, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Tells the given port to write the given amount of bytes at the given address.
Definition: peak_backend.h:135
PEAK_C_API PEAK_BufferChunk_GetParentBuffer(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Asks the given buffer chunk for its parent buffer.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Asks the given firmware update information for its version extraction pattern.
PEAK_C_API PEAK_NodeMap_LoadFromFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Tells the given node map to load the values of its streamable nodes from a file at the given file pat...
PEAK_C_API PEAK_Interface_GetDevice(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Asks the given interface for the device descriptor with the given index.
PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Asks the given node for its number of invalidating nodes.
struct PEAK_REMOTE_DEVICE * PEAK_REMOTE_DEVICE_HANDLE
Definition: peak_backend.h:373
PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Unregisters the device-found callback with the given handle from the given interface.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Asks the given firmware update information whether it is valid.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle)
Unregisters the update step finished callback with the given handle from the given firmware update pr...
int32_t PEAK_BUFFER_PART_TYPE
Definition: peak_backend.h:63
PEAK_C_API PEAK_EventController_GetInfo(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given event controller for an information based on a specific command.
Definition: peak_backend.h:203
Definition: peak_backend.h:274
PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Asks the given port URL for the major component of its file version.
PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Asks the given buffer for its X padding.
PEAK_C_API PEAK_DeviceDescriptor_GetModelName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Asks the given device descriptor for its model name.
PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Asks the given device descriptor whether the device can be opened with exclusive access.
PEAK_C_API PEAK_Node_ToIntegerNode(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Casts the given node to an integer node.
struct PEAK_ENUMERATION_NODE * PEAK_ENUMERATION_NODE_HANDLE
Definition: peak_backend.h:441
Definition: peak_backend.h:259
Definition: peak_backend.h:230
Definition: peak_backend.h:174
PEAK_C_API PEAK_DataStream_StartAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire)
Tells the given data stream to start the acquisition using the given mode and to acquire the given nu...
PEAK_C_API PEAK_BooleanNode_ToNode(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given boolean node to a node.
PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Asks the given buffer for its file name.
Definition: peak_backend.h:88
PEAK_RETURN_CODE_t
Definition: peak_backend.h:315
PEAK_C_API PEAK_SystemDescriptor_GetVendorName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Asks the given system descriptor for its vendor name.
PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Asks the given event for its ID.
Definition: peak_backend.h:186
Definition: peak_backend.h:141
PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Asks the given port whether it is readable.
PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Asks the given buffer whether it has new data since the last delivery.
PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle)
Delete the given device.
Definition: peak_backend.h:151
PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Asks the given buffer for its number of parts.
PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Tells the given integer node to set the given value.
PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Tells the given device descriptor to add the given information role to the monitoring.
Definition: peak_backend.h:99
PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Asks the given buffer whether it is queued.
Definition: peak_backend.h:330
Definition: peak_backend.h:206
Definition: peak_backend.h:123
PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8 *isInitialized)
Checks if the IDS peak API library is initialized.
Definition: peak_backend.h:144
void(PEAK_CALL_CONV * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK)(const PEAK_DEVICE_INFORMATION_ROLE *changedRoles, size_t changedRolesSize, void *context)
Definition: peak_backend.h:511
Definition: peak_backend.h:275
PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Asks the given event for its data.
PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Asks the given buffer for its delivered data size.
PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Asks the given port URL for the minor component of its file schema version.
PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Asks the given data stream for its ID.
PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given string node to a node.
PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Asks for the subminor component of the library version.
PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Casts the given data stream descriptor to a module descriptor.
PEAK_FIRMWARE_UPDATE_STEP_t
Definition: peak_backend.h:179
PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Asks the given buffer for its image offset.
Definition: peak_backend.h:108
PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Locks a recursive mutex on the NodeMap.
Definition: peak_backend.h:58
struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER * PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE
Definition: peak_backend.h:477
PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Asks the given data stream for its key.
struct PEAK_EVENT * PEAK_EVENT_HANDLE
Definition: peak_backend.h:465
PEAK_FIRMWARE_UPDATE_VERSION_STYLE_t
Definition: peak_backend.h:192
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, uint32_t estimatedDuration_ms, const char *description, size_t descriptionSize, void *context)
Definition: peak_backend.h:524
PEAK_C_API PEAK_BufferPart_GetFormatNamespace(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Asks the given buffer part for its format namespace.
struct PEAK_BUFFER * PEAK_BUFFER_HANDLE
Definition: peak_backend.h:385
PEAK_DEVICE_INFORMATION_ROLE_t
Definition: peak_backend.h:131
Definition: peak_backend.h:241
PEAK_C_API PEAK_SystemDescriptor_GetKey(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Asks the given system descriptor for its key.
PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Destroys the given buffer chunk.
PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Asks the given device descriptor for its display name.
Definition: peak_backend.h:271
PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Asks the given buffer part for its delivered image height.
struct PEAK_BOOLEAN_NODE * PEAK_BOOLEAN_NODE_HANDLE
Definition: peak_backend.h:417
PEAK_C_API PEAK_Buffer_ToEventSupportingModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given buffer to an event-supporting module.
PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Asks the given node for its type.
Definition: peak_backend.h:183
PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Asks the given device for its ID.
Definition: peak_backend.h:59
PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Destroys the given event controller.
PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Asks the given system for the minor component of its GenTL version.
PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Waits (blocking) without timeout until the previously executed command is finished, i.e. PEAK_CommandNode_GetIsDone() returns true.
Definition: peak_backend.h:328
Definition: peak_backend.h:317
PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Asks the given device for its number of data streams.
Definition: peak_backend.h:325
PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Tells the given interface to update its devices with the given timeout.
PEAK_C_API PEAK_System_GetDisplayName(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Asks the given system for its display name.
Definition: peak_backend.h:78
PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE
Definition: peak_backend.h:527
Definition: peak_backend.h:124
PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Asks the given float node whether it has a constant increment.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a started update at the given firmware update progress observer...
PEAK_C_API PEAK_Port_Read(PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t *bytesToRead, size_t bytesToReadSize)
Tells the given port to read the given amount of bytes at the given address.
Definition: peak_backend.h:248
PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Tells the given float node to set the given value.
PEAK_C_API PEAK_StringNode_SetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Tells the given string node to set the given value.
Definition: peak_backend.h:56
PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Asks the given port for its data endianness.
PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given float node to a node.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void *context)
Definition: peak_backend.h:540
struct PEAK_STRING_NODE * PEAK_STRING_NODE_HANDLE
Definition: peak_backend.h:429
PEAK_C_API PEAK_DeviceDescriptor_RegisterInformationChangedCallback(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling changed information at the given device descriptor.
int32_t PEAK_NODE_ACCESS_STATUS
Definition: peak_backend.h:208
PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle)
Tells the given buffer to update its parts.
PEAK_DATA_STREAM_FLUSH_MODE_t
Definition: peak_backend.h:93
PEAK_C_API PEAK_Device_GetSerialNumber(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Asks the given device for its serial number.
PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Asks the given float node for its display precision.
PEAK_C_API PEAK_System_GetInfo(PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given system for an information based on a specific command.
PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle)
Destroys the given event.
Definition: peak_backend.h:269
PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Asks the given data stream for its number of buffers awaiting delivery.
void(PEAK_CALL_CONV * PEAK_INTERFACE_LOST_CALLBACK)(const char *lostInterfaceId, size_t lostInterfaceIdSize, void *context)
Definition: peak_backend.h:484
PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Asks the given data stream for its minimum required number of announced buffers.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a started update step at the given firmware update progress observer...
Definition: peak_backend.h:273
Definition: peak_backend.h:96
PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Asks the given system for the major component of its GenTL version.
PEAK_NODE_CHANGED_CALLBACK * PEAK_NODE_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:508
PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Asks the given buffer part for its size.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle)
Unregisters the update finished callback with the given handle from the given firmware update progres...
PEAK_ACQUISITION_START_MODE_t
Definition: peak_backend.h:29
PEAK_C_API PEAK_NodeMap_GetNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Asks the given node map for the node with the given index.
PEAK_C_API PEAK_Device_GetTimestampTickFrequency(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Asks the given device for its timestamp tick frequency.
Definition: peak_backend.h:239
PEAK_C_API PEAK_DataStream_StopAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Tells the given data stream to stop the acquisition using the given mode.
PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Asks the given buffer for its base pointer.
PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Tells the given enumeration node to set its current entry by the given value.
PEAK_C_API PEAK_NodeMap_GetHasNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_BOOL8 *hasNode)
Checks whether the given node map contains a node with the given name.
PEAK_C_API PEAK_Interface_ToEventSupportingModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given interface to an event-supporting module.
PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Asks the given device descriptor for its serial number.
PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Asks the given system descriptor for the major component of its GenTL version.
struct PEAK_FLOAT_NODE * PEAK_FLOAT_NODE_HANDLE
Definition: peak_backend.h:425
PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE
Definition: peak_backend.h:538
#define PEAK_C_API
Definition: peak_backend.h:550
PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Asks the given data stream descriptor for its parent device.
PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Asks the given node for its visibility.
PEAK_C_API PEAK_System_ToEventSupportingModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given system to an event-supporting module.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Asks the given firmware update information for its release notes URL.
PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Asks the given port URL for the subminor component of its file version.
PEAK_C_API PEAK_IntegerNode_GetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t *value)
Asks the given integer node for its value.
PEAK_NODE_VISIBILITY_t
Definition: peak_backend.h:282
Definition: peak_backend.h:161
PEAK_C_API PEAK_DataStream_GetInfo(PEAK_DATA_STREAM_HANDLE dataStreamHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given data stream for an information based on a specific command.
Definition: peak_backend.h:173
PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Asks the given node for its access status.
Definition: peak_backend.h:222
PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Updates chunk information in the node map.
Definition: peak_backend.h:294
PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Asks the given firmware update information for its user set persistence.
PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle)
Destroys the given interface.
PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char *ctiPath, size_t *ctiPathSize)
Asks for the CTI path with the given index.
struct PEAK_SYSTEM * PEAK_SYSTEM_HANDLE
Definition: peak_backend.h:353
PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Asks the given buffer whether it is acquiring.
void(PEAK_CALL_CONV * PEAK_DEVICE_LOST_CALLBACK)(const char *lostDeviceId, size_t lostDeviceIdSize, void *context)
Definition: peak_backend.h:495
Definition: peak_backend.h:295
PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenable(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8 *isOpenable)
Asks the given device descriptor whether the device can be opened with this specific access type...
PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Asks the given node for its parent node map.
PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Asks the given buffer for its X offset.
struct PEAK_SYSTEM_DESCRIPTOR * PEAK_SYSTEM_DESCRIPTOR_HANDLE
Definition: peak_backend.h:349
PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Asks the given buffer part for its format.
PEAK_C_API PEAK_Node_GetInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Asks the given node for the invalidating node with the given index.
PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Asks the given device descriptor for its timestamp tick frequency.
PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Tells the given data stream to start the acquisition using the given mode.
PEAK_C_API PEAK_RegisterNode_Read(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t *bytesToRead, size_t bytesToReadSize)
Tells the given register node to read the given amount of bytes.
PEAK_C_API PEAK_DeviceDescriptor_GetInfo(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given device descriptor for an information based on a specific command.
PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Asks the given node for its name.
struct PEAK_DATA_STREAM * PEAK_DATA_STREAM_HANDLE
Definition: peak_backend.h:381
Definition: peak_backend.h:299
Definition: peak_backend.h:319
PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Creates a firmware updater.
PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Asks for the minor component of the library version.
PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Asks the given module for its number of node maps.
PEAK_C_API PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the information changed callback with the given handle from the given device descriptor...
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Destroys the given firmware update progress observer.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, uint32_t estimatedDuration_ms, void *context)
Definition: peak_backend.h:518
PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Asks the given float node for its increment.
PEAK_C_API PEAK_EventController_GetEventDataMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Asks the event controller for the maximum size of an event's data.
PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle)
Tells the given buffer to update its chunks.
PEAK_C_API PEAK_FloatNode_GetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double *value)
Asks the given float node for its value.
PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Asks the given system descriptor for its display name.
struct PEAK_DEVICE_DESCRIPTOR * PEAK_DEVICE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:365
struct PEAK_PORT * PEAK_PORT_HANDLE
Definition: peak_backend.h:449
PEAK_C_API PEAK_EnumerationNode_GetEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t index, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Asks the given enumeration node for the entry with the given index.
PEAK_C_API PEAK_FirmwareUpdater_UpdateDevice(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Tells the given firmware updater to update the given device with the given update information...
PEAK_C_API PEAK_DataStream_GetBufferAlignment(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Asks the given data stream for its buffer alignment.
PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Asks the given buffer for its number of chunks.
PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Destroys the given producer library.
Definition: peak_backend.h:204
PEAK_C_API PEAK_EnumerationEntryNode_ToNode(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given enumeration entry node to a node.
Definition: peak_backend.h:115
PEAK_C_API PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle)
Tells the given firmware updater to collect all update information fitting to the given device...
Definition: peak_backend.h:297
PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Asks the given buffer whether it is has an image.
PEAK_PIXEL_FORMAT_NAMESPACE_t
Definition: peak_backend.h:292
Definition: peak_backend.h:76
#define PEAK_CALL_CONV
Definition: peak_dynamic_loader.h:29
PEAK_C_API PEAK_NodeMap_StoreToFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Tells the given node map to store the values of its streamable nodes to a file at the given file path...
PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Tells the given device descriptor to remove the given information role from the monitoring.
Definition: peak_backend.h:101
PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Asks the given data stream for its payload size.
PEAK_C_API PEAK_System_GetInterface(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Asks the given system for the interface descriptor with the given index.
Definition: peak_backend.h:182
Definition: peak_backend.h:205
PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Asks the given port for its name.
PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Asks the given register node for its address.
PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Asks the given port URL for its file size.
PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Asks the given buffer part for its type.
PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Asks the given module for its port.
PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Asks the given buffer part for its base pointer.
PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:515
PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Unlocks the recursive mutex on the NodeMap.
PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Asks the given port whether it is implemented.
Definition: peak_backend.h:276
PEAK_C_API PEAK_FloatNode_GetValidValues(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Asks the given float node for its valid values.
Definition: peak_backend.h:73
PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Casts the given node to a float node.
PEAK_C_API PEAK_EventController_GetNumEventsInQueue(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Asks the event controller for its number of events in queue.
PEAK_C_API PEAK_Node_ToBooleanNode(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Casts the given node to a boolean node.
int32_t PEAK_FIRMWARE_UPDATE_STEP
Definition: peak_backend.h:189
int32_t PEAK_BUFFER_PAYLOAD_TYPE
Definition: peak_backend.h:82
int32_t PEAK_NODE_CACHE_USE_POLICY
Definition: peak_backend.h:225
Definition: peak_backend.h:306
Definition: peak_backend.h:152
PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Asks the given interface for its number of devices.
PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Asks the given system for its version.
PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Asks the given port for its vendor name.
PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Asks the given port URL for its URL string.
Definition: peak_backend.h:98
int32_t PEAK_DEVICE_ACCESS_STATUS
Definition: peak_backend.h:117
PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Asks the given device descriptor for its user-defined name.
PEAK_C_API PEAK_Interface_GetParentSystem(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Asks the given interface for its parent system.
struct PEAK_INTERFACE * PEAK_INTERFACE_HANDLE
Definition: peak_backend.h:361
PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Tells the given node map to invalidate its nodes.
PEAK_C_API PEAK_EnumerationNode_FindEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Tells the given enumeration node to find a entry with the given symbolic value.
PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Asks the given data stream for its maximum number of chunks per buffer.
PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Asks the given enumeration entry node for its symbolic value.
PEAK_C_API PEAK_EnumerationNode_GetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Asks the given enumeration node for its current entry.
Definition: peak_backend.h:215
PEAK_C_API PEAK_BufferPart_GetInfo(PEAK_BUFFER_PART_HANDLE bufferPartHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given buffer part for an information based on a specific command.
PEAK_C_API PEAK_RemoteDevice_ToModule(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Casts the given remote device to a module.
Definition: peak_backend.h:126
PEAK_C_API PEAK_Port_GetInfo(PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given port for an information based on a specific command.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, void *context)
Definition: peak_backend.h:535
PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Tells the given device descriptor to set the given monitoring update interval.
int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE
Definition: peak_backend.h:176
PEAK_C_API PEAK_InterfaceDescriptor_GetKey(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Asks the given interface descriptor for its key.
PEAK_C_API PEAK_Device_ToEventSupportingModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given device to an event-supporting module.
PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Asks the given port URL for the minor component of its file version.
PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Asks the given system for its ID.
PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Tells the given firmware updater to collect all update information from the .guf file.
Definition: peak_backend.h:285
PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Asks the given port URL for its file register address.
PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Asks the given device for its TL type.
PEAK_C_API PEAK_Node_GetSelectedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Asks the given node for the selected node with the given index.
PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Asks the given data stream for its number of underruns.
PEAK_NODE_TYPE_t
Definition: peak_backend.h:267
int32_t PEAK_PIXEL_FORMAT_NAMESPACE
Definition: peak_backend.h:301
PEAK_C_API PEAK_IntegerNode_GetRepresentation(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Asks the given integer node for its representation.
PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Asks the given interface descriptor for its parent system.
PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Asks the given buffer for its TL type.
struct PEAK_BUFFER_CHUNK * PEAK_BUFFER_CHUNK_HANDLE
Definition: peak_backend.h:389
Definition: peak_backend.h:87
Definition: peak_backend.h:61
PEAK_C_API PEAK_CategoryNode_ToNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given category node to a node.
PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Asks the given buffer for its pixel format.
Definition: peak_backend.h:257
Definition: peak_backend.h:140
PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Asks the given command node whether its associated command is done.
struct PEAK_FIRMWARE_UPDATE_INFORMATION * PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE
Definition: peak_backend.h:473
PEAK_C_API PEAK_SystemDescriptor_GetModelName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Asks the given system descriptor for its model name.
Definition: peak_backend.h:194
PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Asks the given buffer whether it is incomplete.
PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Checks if the event contains data corresponding to the node map.
void(PEAK_CALL_CONV * PEAK_BUFFER_REVOCATION_CALLBACK)(void *buffer, void *userPtr, void *context)
Definition: peak_backend.h:503
void(PEAK_CALL_CONV * PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void *context)
Definition: peak_backend.h:506
PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE
Definition: peak_backend.h:522
struct PEAK_MODULE * PEAK_MODULE_HANDLE
Definition: peak_backend.h:401
PEAK_C_API PEAK_ModuleDescriptor_GetID(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Asks the given module descriptor for its ID.
PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle)
Destroys the given system.
PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Asks the given buffer for its size.
PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Asks the given firmware update information for its sequencer set persistence.
PEAK_C_API PEAK_EventController_GetNumEventsFired(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Asks the event controller for its number of fired events.
PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Unregisters the device-lost callback with the given handle from the given interface.
PEAK_C_API PEAK_Device_GetDataStream(PEAK_DEVICE_HANDLE deviceHandle, size_t index, PEAK_DATA_STREAM_DESCRIPTOR_HANDLE *dataStreamDescriptorHandle)
Asks the given device for the data stream descriptor with the given index.
PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Asks the given buffer part for its source ID.
PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Asks the given node for its description.
PEAK_C_API PEAK_InterfaceDescriptor_GetInfo(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given interface descriptor for an information based on a specific command.
PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Asks the given device descriptor for its monitoring update interval.
PEAK_DEVICE_LOST_CALLBACK * PEAK_DEVICE_LOST_CALLBACK_HANDLE
Definition: peak_backend.h:500
Definition: peak_backend.h:68
PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Asks the given node for its tooltip.
Definition: peak_backend.h:97
struct PEAK_DEVICE * PEAK_DEVICE_HANDLE
Definition: peak_backend.h:369
struct PEAK_COMMAND_NODE * PEAK_COMMAND_NODE_HANDLE
Definition: peak_backend.h:421
PEAK_C_API PEAK_DataStream_ToEventSupportingModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Casts the given data stream to an event-supporting module.
Definition: peak_backend.h:258
PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Asks the given buffer for its width.
PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Asks the given node whether its access status is cacheable.
PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Asks the given system for its number of interfaces.
PEAK_C_API PEAK_Device_GetVendorName(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Asks the given device for its vendor name.
PEAK_C_API PEAK_NodeMap_FindNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE *nodeHandle)
Tells the given node map to find a node with the given name.
PEAK_C_API PEAK_EnumerationNode_FindEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Tells the given enumeration node to find a entry with the given value.
PEAK_C_API PEAK_EventController_GetControlledEventType(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Asks the event controller for its controlled event type.
PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Asks the given float node for its unit.
PEAK_NODE_ACCESS_STATUS_t
Definition: peak_backend.h:200
Definition: peak_backend.h:160
PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Asks the given buffer chunk for its ID.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle)
Unregisters the update failed callback with the given handle from the given firmware update progress ...
PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Asks the given buffer part for its width.
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(const char *errorDescription, size_t errorDescriptionSize, void *context)
Definition: peak_backend.h:544
PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Asks the given port whether it is available.
PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Asks the given port whether it is writable.
PEAK_NODE_CACHING_MODE_t
Definition: peak_backend.h:211
PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Asks for the major component of the library version.
PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Asks the given event for its raw data.
PEAK_C_API PEAK_Library_Initialize()
Initializes the IDS peak API library.
PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Asks the given buffer for its frame ID.
int32_t PEAK_NODE_REPRESENTATION
Definition: peak_backend.h:264
struct PEAK_DATA_STREAM_DESCRIPTOR * PEAK_DATA_STREAM_DESCRIPTOR_HANDLE
Definition: peak_backend.h:377
Definition: peak_backend.h:195
Definition: peak_backend.h:240
Definition: peak_backend.h:166
Definition: peak_backend.h:331
Definition: peak_backend.h:249
PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Asks the given buffer for its Y padding.
PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Asks the given port URL for its file name.
PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Asks the given string node for its maximum length.
PEAK_INTERFACE_LOST_CALLBACK * PEAK_INTERFACE_LOST_CALLBACK_HANDLE
Definition: peak_backend.h:489
PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Tells the given event controller to kill a wait for an event.
PEAK_INTERFACE_FOUND_CALLBACK * PEAK_INTERFACE_FOUND_CALLBACK_HANDLE
Definition: peak_backend.h:487
PEAK_C_API PEAK_Buffer_GetChunk(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Asks the given buffer for the chunk with the given index.
PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Opens the data stream being associated with the given data stream descriptor.
PEAK_C_API PEAK_DeviceDescriptor_GetKey(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Asks the given device descriptor for its key.
PEAK_DEVICE_ACCESS_TYPE_t
Definition: peak_backend.h:120
PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Asks the given data stream whether it defines the payload size.
PEAK_C_API PEAK_Event_GetInfo(PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Asks the given event for an information based on a specific command.
PEAK_C_API PEAK_Node_ToCategoryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Casts the given node to a category node.
PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Asks the given interface for its ID.
int32_t PEAK_FIRMWARE_UPDATE_VERSION_STYLE
Definition: peak_backend.h:197
PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Tells the given system to update its interfaces with the given timeout.
struct PEAK_BUFFER_PART * PEAK_BUFFER_PART_HANDLE
Definition: peak_backend.h:393
PEAK_C_API PEAK_Node_UnregisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Unregisters the changed callback with the given handle from the given node.
PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Asks the given port for its module name.
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE *callbackHandle)
Registers a callback signaling a finished update step at the given firmware update progress observer...
struct PEAK_REGISTER_NODE * PEAK_REGISTER_NODE_HANDLE
Definition: peak_backend.h:433
PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:533
PEAK_BUFFER_PAYLOAD_TYPE_t
Definition: peak_backend.h:66
Definition: peak_backend.h:187
PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Asks the given buffer part for its X padding.
Definition: peak_backend.h:163
PEAK_C_API PEAK_Node_GetInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Asks the given node for the invalidated node with the given index.
PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Asks the given node whether it is cacheable.
const uint64_t PEAK_INFINITE_TIMEOUT
Definition: peak_backend.h:341
PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Asks the given port for its TL type.
PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Asks the given system for its model name.
PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Casts the given node to a string node.
PEAK_C_API PEAK_Buffer_GetPixelEndianness(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Asks the given buffer for its pixel endianness.
PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Tells the given command node to execute its associated command.
PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Asks the given buffer chunk for its size.
PEAK_C_API PEAK_CommandNode_ToNode(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Casts the given command node to a node.
PEAK_CHARACTER_ENCODING_t
Definition: peak_backend.h:85
PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle)
Unregisters the update step started callback with the given handle from the given firmware update pro...
PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE
Definition: peak_backend.h:547
Definition: peak_backend.h:122
PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Asks the given firmware update information for its version.
Definition: peak_backend.h:75
