Updating prebuilts and/or headers

8193be73ce0a488f62034cb87083cdf09f52cd5d - event_sample_app/block_pool.c
a0bd135d707994a41ed3a4234b5f875a268fed4d - event_sample_app/Makefile
44f6de348f8bdd5cb584b3e8cc4b05e9482dddd2 - event_sample_app/event_loop.h
6ff0f1c2d7ef2e2fa9ece6fdc850b58b87207526 - event_sample_app/block_returnsync.c
1158201e78094e9e866fa99095c9ffc2ec9f5a27 - event_sample_app/block_limiter.c
f5e2aea98ba9264ee1068a700222dff8d5d5c7a4 - event_sample_app/block_c2c.c
ef057870dade9af70656b37340e9bcad35d49380 - event_sample_app/block_multicast.c
641e3634da873970b574b23a1024b2e7155b88ff - event_sample_app/block_consumer_uc1.c
ced622a41d1a48dcb23e6a1a02ae9640ef9b837c - event_sample_app/util.h
3a1013021a572887303fb6db245b5b01fe07e9a0 - event_sample_app/block_producer_uc1.c
dac99c442185b020fbdae07bfc1e7df78343eb83 - event_sample_app/block_info.h
b5dd68bec3ae6f9049aad1cb5a86c3db4af02e17 - event_sample_app/block_presentsync.c
e0861e9fe5d160d47d758464146d7192f9c70a5f - event_sample_app/util.c
d7e42e2b6088ff4596abc7256eb018d757a4021e - event_sample_app/usecase1.h
65ffe5af6ae6bc0418f348167c473849d4697e47 - event_sample_app/block_ipc.c
b52e34443ac441a9df48029de944aa0a50d1b101 - event_sample_app/event_loop_service.c
5001f036389a4f7952cb4974dd3323908208ca30 - event_sample_app/event_loop_threads.c
a71ed037f9d77d0944f40f54cf25db8180d007e2 - event_sample_app/block_queue.c
d6bbd17599543f1760d87851150a12a2a842a24d - event_sample_app/block_common.c
40f949c4c37ab4aa4a84182b345f3de6fceab39b - event_sample_app/main.c
458833ab233a725c067bf9b1fc60ef39872eee80 - rawstream/Makefile
1fbb82e2281bb2e168c87fd20903bbed898ca160 - rawstream/rawstream_cuda.c
e26c09f1ad1a3a7d2c29dae1b38d3fd90c23af6e - rawstream/rawstream_consumer.c
2bed038ca070aa5dccd6b672a98f093340e829bb - rawstream/rawstream_producer.c
3df4e5c00a3dc002ee9877e282bd28ffa87fa6f0 - rawstream/rawstream.h
d5ffeef3c7ad2af6f6f31385db7917b5ef9a7438 - rawstream/rawstream_ipc_linux.c
f28c1cd5fe26b6dc5930d5556b54364c9b91767c - rawstream/rawstream_main.c

Change-Id: I938f32e9d8445019e4585b3076bc6cac860f8a0f

event_sample_app/block_common.c

@@ -0,0 +1,177 @@
+/* NvSciStream Event Loop Driven Sample App - common block event handling
+ *
+ * Copyright (c) 2021-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
+ */
+
+/*
+ * Block types which do not require type-specific interactions make use of
+ *   this common code.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "nvscistream.h"
+#include "block_info.h"
+#include "event_loop.h"
+
+/* Delete common block */
+void deleteCommon(
+    void* data)
+{
+    BlockData* blockData = (BlockData*)data;
+
+    /* Destroy block */
+    if (blockData->block != 0) {
+        (void)NvSciStreamBlockDelete(blockData->block);
+    }
+
+    /* Free data */
+    free(blockData);
+}
+
+/* Handle events on a common block
+ *
+ * Blocks that don't require interaction after connection usually just
+ *   receive notification of connection and disconnection.
+ */
+int32_t handleCommon(
+    void*     data,
+    uint32_t  wait)
+{
+    /* Cast to common data */
+    BlockData* blockData = (BlockData*)data;
+
+    /* Get time to wait */
+    int64_t waitTime = wait ? blockData->waitTime : 0;
+
+    /* Query/wait for an event on the block */
+
+    NvSciStreamEventType event;
+    NvSciError       err;
+    err = NvSciStreamBlockEventQuery(blockData->block, waitTime, &event);
+
+    /* Handle errors */
+    if (NvSciError_Success != err) {
+
+        /* If not asked to wait, a timeout is not an error */
+        if (!waitTime && (NvSciError_Timeout == err)) {
+            return 0;
+        }
+
+        /* Otherwise, any error is considered fatal. A timeout probably
+         *   indicates a failure to connect and complete setup in a timely
+         *   fashion, so we specifically call out this case.
+         */
+        if (NvSciError_Timeout == err) {
+            printf("%s timed out waiting for setup instructions\n",
+                   blockData->name);
+        } else {
+            printf("%s event query failed with error %x\n",
+                   blockData->name, err);
+        }
+        blockData->deleteFunc(blockData);
+        return -1;
+    }
+
+    /* If we received an event, handle it based on its type */
+    int32_t rv = 1;
+    NvSciError status;
+    switch (event) {
+
+    /*
+     * Any event we don't explicitly handle is a fatal error
+     */
+    default:
+        printf("%s received unknown event %x\n",
+               blockData->name, event);
+
+        rv = -1;
+        break;
+
+    /*
+     * Error events should never occur with safety-certified drivers,
+     *   and are provided only in non-safety builds for debugging
+     *   purposes. Even then, they should only occur when something
+     *   fundamental goes wrong, like the system running out of memory,
+     *   or stack/heap corruption, or a bug in NvSci which should be
+     *   reported to NVIDIA.
+     */
+    case NvSciStreamEventType_Error:
+        err = NvSciStreamBlockErrorGet(blockData->block, &status);
+        if (NvSciError_Success != err) {
+            printf("%s Failed to query the error event code %x\n",
+                   blockData->name, err);
+        } else {
+            printf("%s received error event: %x\n",
+                   blockData->name, status);
+        }
+
+        rv = -1;
+        break;
+
+    /*
+     * If told to disconnect, it means either the stream finished its
+     *   business or some other block had a failure. We'll just do a
+     *   clean up and return without an error.
+     */
+    case NvSciStreamEventType_Disconnected:
+        rv = 2;
+        break;
+
+    /*
+     * The block doesn't have to do anything on connection, but now we may
+     *   wait forever for any further events, so the timeout becomes infinite.
+     */
+    case NvSciStreamEventType_Connected:
+        /* Query producer and consumer(s) endpoint info if needed */
+        blockData->waitTime = -1;
+        break;
+
+    /* All setup complete. Transition to runtime phase */
+    case NvSciStreamEventType_SetupComplete:
+        break;
+    }
+
+    /* On failure or final event, clean up the block */
+    if ((rv < 0) || (1 < rv)) {
+        blockData->deleteFunc(blockData);
+    }
+
+    return rv;
+}
+
+/* Create and register a new common block */
+BlockData* createCommon(
+    char const* name,
+    size_t      size)
+{
+    /* If no size specified, just use BlockData */
+    if (0 == size) {
+        size = sizeof(BlockData);
+    }
+
+    /* Create a data structure to track the block's status */
+    BlockData* commonData = (BlockData*)calloc(1, size);
+    if (NULL == commonData) {
+        printf("Failed to allocate data structure for %s\n", name);
+        return NULL;
+    }
+
+    /* Save the name for debugging purposes */
+    strcpy(commonData->name, name);
+
+    /* Wait time for initial connection event will be 60 seconds */
+    commonData->waitTime = 60 * 1000000;
+
+    /* Use the common delete function */
+    commonData->deleteFunc = deleteCommon;
+
+    return commonData;
+}