### Run Tokenizer Example

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/utils/tokenizers/README.md

Execute the provided example program. It can use the default tokenizer configuration or a custom path specified as a command-line argument.

```bash
# Run with default tokenizer.json path
./builddir/tokenizer_example

# Run with custom tokenizer path
./builddir/tokenizer_example /path/to/your/tokenizer.json
```

--------------------------------

### Run the AI Example Application

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/README.rst

Execute this command on the Hailo15 platform to run the pre-compiled AI example application. This will display the video feed with inference overlays.

```bash
$ ./apps/ai_example_app/ai_example_app
```

--------------------------------

### Start Camera Viewer Server

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/README.rst

SSH into the device and start the camera viewer server. Access the viewer via a web browser on the host machine.

```bash
ssh root@10.0.0.1
camera-viewer-server
```

--------------------------------

### Run AI Example App on Device

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

Executes the pre-compiled AI example application on the Hailo-15 device via SSH. Various command-line arguments control its behavior, including timeout, FPS printing, configuration file, profile, overlay drawing, and host IP.

```bash
ssh root@10.0.0.1
./apps/ai_example_app/ai_example_app \
    --timeout 120 \
    --print-fps \
    --config-file-path /etc/imaging/cfg/medialib_configs/ai_example_medialib_config.json \
    --profile "Daylight" \
    --draw-overlay "0,1" \
    --host-ip 10.0.0.2
```

--------------------------------

### Install Dependencies

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/utils/clip_encoder_onnx/README.md

Install the necessary Python packages for ONNX export and Hailo binary generation.

```bash
pip install torch torchvision clip-by-openai onnx onnxruntime numpy
```

--------------------------------

### Get Help for File Source to UDP Case Study

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/file_source_to_udp/README.rst

Use this command to display all available command-line options and their descriptions for the file_source_to_udp_case_study executable.

```bash
# Get help
./file_source_to_udp_case_study --help
```

--------------------------------

### Install Optional GStreamer Plugins

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/tools/cross_compiler/README.rst

Optionally, add Python support and GStreamer trace hooks for GStreamer plugins.

```sh
# GStreamer plugins
IMAGE_INSTALL_append += "                    \
    gstreamer1.0-python                      \
    gst-instruments                          \
"

# Enable trace hooks for GStreamer
PACKAGECONFIG_append_pn-gstreamer1.0 += " gst-tracer-hooks"

```

--------------------------------

### Run Single Stream Application on Hailo15

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/single_stream/README.rst

Execute this command on the Hailo15 platform to start the single stream application.

```bash
$ ./apps/case_studies/single_stream/single_stream_case_study
```

--------------------------------

### Stage Start Method

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/app_structure.rst

Starts the stage by setting the end-of-stream flag to false and launching the main processing loop in a new thread.

```cpp
AppStatus start()
            {
                m_end_of_stream = false;
                m_thread = std::thread(&Stage::loop, this);
                return AppStatus::SUCCESS;
            }
```

--------------------------------

### Get WebRTC Offer

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Client requests an SDP offer from the server to initiate a connection.

```APIDOC
## POST /api/webrtc/offer

### Description
Client requests an SDP offer from the server to initiate a connection.

### Method
POST

### Endpoint
/api/webrtc/offer

### Parameters
#### Request Body
- **session_id** (string) - Required - The session ID obtained from creating a WebRTC session.

### Request Example
```json
{
  "session_id": "the-session-id-from-above"
}
```

### Success Response (200 OK)
A standard WebRTC SDP offer.
```json
{
  "type": "offer",
  "sdp": "v=0\r\no=- ...\r\n"
}
```

### Error Response
- 500 Invalid: If request is invalid
- 400 Internal Server Error: If internal extension module service is not found
```

--------------------------------

### Complete CLIP Text Encoder Workflow Example

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/utils/clip_encoder_onnx/README.md

A three-step workflow to generate the ONNX model, create binary files, and validate the results for Hailo-accelerated CLIP text encoding.

```bash
# Step 1: Generate ONNX model
python clip_text_encode_onnx_export.py --model "ViT-B/32"
```

```bash
# Step 2: Create binary files
python clip_text_hailo_binary_export.py \
    --onnx-path clip_vit_b32_text_encoder_full.onnx \
    --output-dir vit_b_32_binary
```

```bash
# Step 3: Validate results
python clip_text_encoder_full_test.py \
    --prompt "a photo of a dog playing in the park" \
    --bin-folder ./vit_b_32_binary \
    --hailo-onnx-path ./clip_vit_b32_text_encoder_full.onnx \
    --model "ViT-B/32" \
    --output-dir ./validation_results
```

--------------------------------

### Run Detection Application on Hailo15 Platform

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/detection/README.rst

Execute the detection case study application on the Hailo15 platform after starting the host streaming pipeline. This will display the video feed with inference overlays.

```bash
$ ./apps/case_studies/detection/detection_case_study
```

--------------------------------

### Start AI Pipeline

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/app_structure.rst

Initiates the execution of the configured AI pipeline. This is a crucial step before the application begins processing data.

```cpp
// Start pipeline
std::cout << "Starting." << std::endl;
app_resources->pipeline->start_pipeline();
```

--------------------------------

### Start Pipeline Stages

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/app_structure.rst

Starts all stages within the pipeline in a specific order: sink, general, and then source stages. This ensures data flows correctly through the processing chain.

```cpp
void start_pipeline()
                {
                    // Start the sink stages
                    for (auto &stage : m_sink_stages)
                    {
                        stage->start();
                    }

                    // Start the general stages
                    for (auto &stage : m_gen_stages)
                    {
                        stage->start();
                    }

                    // Start the source stages
                    for (auto &stage : m_src_stages)
                    {
                        stage->start();
                    }
                }
```

--------------------------------

### Run record_perf Script

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/scripts/misc/internals/record_perf/README.rst

Execute the record_perf.sh script to start recording performance data. Specify the duration for which the recording should run.

```sh
./scripts/misc/internals/record_perf/record_perf.sh <time>
```

--------------------------------

### Build Debug Version with Device Deployment

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

Compiles a debug version for Hailo-15 and deploys it to the device. Requires specifying the toolchain path, remote machine IP, and installation target.

```bash
./tools/cross_compiler/cross_compile_native_apps.py \
    hailo15 debug /path/to/toolchain \
    --remote-machine-ip 10.0.0.1 \
    --install-to-rootfs
```

--------------------------------

### Cross-Compile Script Help

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/compiling.rst

View the help message for the cross-compilation script to understand available flags and arguments. This includes build types, target platforms, and options for cleaning the build directory or installing to rootfs.

```sh
$ ./cross_compile_native_apps.py --help
```

--------------------------------

### Run Dynamic Privacy Mask Application on Hailo15

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/dynamic_privacy_mask/README.rst

Execute this command on the Hailo15 platform to start the dynamic privacy mask application. This will process the incoming video feed and apply masking.

```bash
$ ./apps/case_studies/dynamic_privacy_mask/dynamic_privacy_mask_case_study
```

--------------------------------

### Cross-Compile Native Apps

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/compiling.rst

Execute this script to cross-compile native applications. Ensure the Hailo-15 SDK is installed and provide the path to your toolchain.

```sh
$ ./tools/cross_compiler/cross_compile_native_apps.py hailo15 release <path-to-your-toolchain>
```

--------------------------------

### Get WebRTC Offer for Connection

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Client requests an SDP offer from the server to initiate a WebRTC connection. Requires a session ID obtained from creating a session.

```json
{
  "session_id": "the-session-id-from-above"
}
```

```json
{
  "type": "offer",
  "sdp": "v=0\r\no=- ...\r\n"
}
```

--------------------------------

### Start WebRTC Stream

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/index.html

Initiates the WebRTC streaming process. It requests a session if needed, configures the RTCPeerConnection with STUN servers, and sets up handlers for ICE candidates and remote tracks. It then fetches an offer from the server, creates an answer, and sends it back.

```javascript
async startStream() {
        try {
            this.log('Starting WebRTC connection...');
            this.updateStatus('connecting');
            // Request session if we don't have one
            if (!this.sessionId) {
                await this.requestStreamingSession();
            }
            this.peerConnection = new RTCPeerConnection({
                iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
            });
            this.peerConnection.onicecandidate = (event) => {
                if (event.candidate) {
                    this.log('Sending ICE candidate');
                    this.sendIceCandidate(event.candidate);
                } else {
                    this.log('ICE gathering complete');
                }
            };
            this.peerConnection.ontrack = (event) => {
                this.log('Received remote track');
                this.videoElement.srcObject = event.streams[0];
                this.videoElement.style.display = 'block';
                this.videoControls.classList.add('hidden');
                this.isPlaying = true;
                this.videoElement.play().catch(err => {
                    this.log('Video play failed: ' + err.message);
                });
                this.updateStatus('connected');
                // Stop reconnection attempts on successful connection
                this.stopReconnectionAttempts();
            };
            this.peerConnection.onconnectionstatechange = () => {
                this.log(`Connection state: ${this.peerConnection.connectionState}`);
                if (this.peerConnection.connectionState === 'connected') {
                    this.updateStatus('connected');
                } else if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed') {
                    this.updateStatus('disconnected');
                    this.sessionId = null;
                    this.handleConnectionLost();
                }
            };
            this.peerConnection.oniceconnectionstatechange = () => {
                this.log(`ICE connection state: ${this.peerConnection.iceConnectionState}`);
            };
            const response = await fetch('/api/webrtc/offer', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ session_id: this.sessionId })
            });
            if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
            const offer = await response.json();
            this.log('Received offer from server');
            await this.peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
            const answer = await this.peerConnection.createAnswer();
            await this.peerConnection.setLocalDescription(answer);
            await fetch('/api/webrtc/answer', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ session_id: this.sessionId, type: 'answer', sdp: answer.sdp })
            });
            this.log('Answer sent to server');
        } catch (error) {
            this.log(`Error starting stream: ${error.message}`);
            this.updateStatus('disconnected');
            this.videoElement.style.display = 'none';
            this.videoControls.classList.remove('hidden');
            this.isPlaying = false;
            throw error; // Re-throw to handle in reconnection logic
        }
    }
```

--------------------------------

### Start WebRTC Video Playback

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/index.html

Establishes a WebRTC peer connection, sets up event handlers for ICE candidates and track events, and manages the remote description offer. Handles connection states and playback initiation.

```javascript
async startVideoPlayback() {
    if (!this.sessionId || !this.currentVideoInfo) return;
    try {
      this.updateStatus('connecting');
      if (!this.isPlaying) {
        await this.sendVideoInfo(this.currentVideoInfo);
      }
      this.peerConnection = new RTCPeerConnection({
        iceServers: [{"urls": "stun:stun.l.google.com:19302"}]
      });
      this.peerConnection.onicecandidate = (event) => {
        if (event.candidate) {
          this.sendIceCandidate(event.candidate);
        }
      };
      this.peerConnection.ontrack = (event) => {
        this.videoElement.srcObject = event.streams[0];
        this.videoElement.style.display = 'block';
        this.videoControls.classList.add('hidden');
        this.isPlaying = true;
        this.videoElement.play().catch(err => {
          console.error('Video play failed:', err);
        });
        this.updateStatus('connected');
        this.resetFrameTimeout();
      };
      this.peerConnection.onconnectionstatechange = () => {
        console.log(`Video connection state: ${this.peerConnection.connectionState}`);
        if (this.peerConnection.connectionState === 'connected') {
          this.updateStatus('connected');
        } else if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed') {
          this.updateStatus('disconnected');
          this.videoElement.style.display = 'none';
          this.videoControls.classList.remove('hidden');
          this.isPlaying = false;
        }
      };
      const response = await fetch('/api/webrtc/offer', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ session_id: this.sessionId })
      });
      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
      const offer = await response.json();
      await this.peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
      const answer = await this.peerConnection.createAnswer();
      await this.peerConnection.setLocalDescription(answer);
      await fetch('/api/webrtc/answer', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ session_id: this.sessionId, type: 'answer', sdp: answer.sdp })
      });
    } catch (error) {
      console.error('Error starting video playback:', error);
      this.updateStatus('disconnected');
      this.videoElement.style.display = 'none';
      this.videoControls.classList.remove('hidden');
      this.isPlaying = false;
    }
  }
```

--------------------------------

### Start Storage Data Polling (JavaScript)

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/index.html

Initiates the process of fetching storage data. It performs an initial fetch immediately and then sets up an interval to fetch data every 2 seconds using `fetchStorageData`.

```javascript
startPolling() {
  // Initial fetch
  this.fetchStorageData();
  // Poll every 2 seconds
  this.pollingInterval = setInterval(() => {
    this.fetchStorageData();
  }, 2000);
}
```

--------------------------------

### GStreamer Detection Pipeline with hailofrontendbinsrc and hailonet

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

This pipeline performs object detection using hailofrontendbinsrc for input, hailonet for neural network inference, and hailofilter for post-processing. It then overlays the results, encodes the video, and streams it over UDP. The example includes both the device-side pipeline and the host-side receiver pipeline.

```bash
# apps/h15/gstreamer/detection/detection.sh
# Run on Hailo-15 device:

./apps/detection/detection.sh --mode daylight --show-fps

# Equivalent hand-crafted gst-launch-1.0 command:
gst-launch-1.0 \
    hailofrontendbinsrc config-file-path=/etc/imaging/cfg/frontend_config.json name=frontend \
    frontend. ! \
        queue leaky=no max-size-buffers=5 max-size-bytes=0 max-size-time=0 ! \
        hailonet hef-path=/usr/share/hailo-models/yolov5m_wo_spp_60p_nv12_fhd.hef \
                 scheduling-algorithm=1 vdevice-group-id=device0 ! \
        queue leaky=no max-size-buffers=5 max-size-bytes=0 max-size-time=0 ! \
        hailofilter function-name=yolov5 \
                    config-path=/usr/share/hailo-models/yolov5.json \
                    so-path=/usr/lib/hailo-post-processes/libyolo_post.so qos=false ! \
        queue leaky=no max-size-buffers=5 max-size-bytes=0 max-size-time=0 ! \
        hailooverlay qos=false ! \
        queue leaky=no max-size-buffers=5 max-size-bytes=0 max-size-time=0 ! \
        hailoencodebin config-file-path=/etc/imaging/cfg/encoder_config.json ! \
        h264parse config-interval=-1 ! \
        video/x-h264,framerate=30/1 ! \
        tee name=t \
        t. ! queue leaky=no max-size-buffers=5 ! \
               rtph264pay ! 'application/x-rtp,media=video,encoding-name=H264' ! \
               udpsink host=10.0.0.2 port=5000 sync=false \
        t. ! fpsdisplaysink fps-update-interval=2000 video-sink=fakesink sync=false

# On host machine to receive:
gst-launch-1.0 udpsrc port=5000 address=10.0.0.2 \
    ! application/x-rtp,encoding-name=H264 \
    ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no \
    ! rtpjitterbuffer mode=0 \
    ! rtph264depay ! h264parse ! avdec_h264 \
    ! videoconvert n-threads=8 \
    ! fpsdisplaysink text-overlay=false sync=false
```

--------------------------------

### Display Application Help and Options

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/README.rst

Run this command to view the available command-line options for the ai_example_app. This includes flags for controlling timeout, FPS printing, latency, configuration files, and drawing overlays.

```bash
$ ./apps/ai_example_app/ai_example_app --help
```

--------------------------------

### Get Server Status

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Checks the basic health and status of the web server.

```APIDOC
## GET /api/status

### Description
Checks the basic health and status of the web server.

### Method
GET

### Endpoint
/api/status

### Response
#### Success Response (200 OK)
- status (string) - Always "ok" if the server is running.
- timestamp (number) - Current server time as a UNIX timestamp in milliseconds.

### Response Example
```json
{
  "status": "ok",
  "timestamp": 1678886400000
}
```
```

--------------------------------

### Main Application Entry Point

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/app_structure.rst

The main function serves as the entry point for the application. It initializes application resources and sets up signal handling for graceful shutdown.

```cpp
int main(int argc, char *argv[])
                {
                    {
                        // App resources 
                        std::shared_ptr<AppResources> app_resources = std::make_shared<AppResources>();
                        app_resources->frontend_config = FRONTEND_CONFIG_FILE;

                        // register signal SIGINT and signal handler
                        signal_utils::SignalHandler signal_handler(false);
                        signal_handler.register_signal_handler([app_resources](int signal) {
                            std::cout << "Stopping Pipeline..." << std::endl;

```

--------------------------------

### Constructing and Using the Buffer Container

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

Demonstrates the construction of a `Buffer` object, typically from a raw frame, and how to access its image data and inference results. It also shows how to add and retrieve typed metadata and timestamps for profiling.

```cpp
// pipeline_infra/buffer.hpp
#include "buffer.hpp"
#include "media_library/media_library_types.hpp"

// --- Construction ---
// Typically constructed when the FrontendStage receives a new frame from Media Library:
HailoMediaLibraryBufferPtr raw_buf = ...; // received from Media Library frontend callback
BufferPtr buf = std::make_shared<Buffer>(raw_buf);
// Buffer auto-initialises a full-frame HailoROI (0,0,1,1) and a "Source" timestamp.

// --- Reading image data ---
HailoMediaLibraryBufferPtr img = buf->get_buffer();
uint8_t* y_plane  = (uint8_t*)img->get_plane_ptr(0);   // luma plane (NV12)
uint8_t* uv_plane = (uint8_t*)img->get_plane_ptr(1);   // chroma plane (NV12)
size_t   stride   = img->get_plane_stride(0);
uint32_t width    = img->buffer_data->width;
uint32_t height   = img->buffer_data->height;

// --- Accessing inference results ---
HailoROIPtr roi = buf->get_roi();
auto detections = hailo_common::get_hailo_detections(roi);
for (auto& det : detections) {
    std::cout << det->get_label()
              << " conf=" << det->get_confidence()
              << " bbox=(" << det->get_bbox().xmin() << ","
                           << det->get_bbox().ymin() << ")\n";
}

// --- Adding typed metadata ---
// Attach tensor metadata (used by HailortAsyncStage to pass raw output tensors downstream)
BufferPtr tensor_buf = std::make_shared<Buffer>(tensor_raw_buf);
TensorMetadataPtr tm = std::make_shared<TensorMetadata>(tensor_buf, "output_layer0");
buf->add_metadata(tm);

// Retrieve specific metadata type
std::vector<MetadataPtr> size_metas = buf->get_metadata_of_type(MetadataType::SIZE);
SizeMetadataPtr sz = std::dynamic_pointer_cast<SizeMetadata>(size_metas[0]);
size_t encoded_bytes = sz->get_size();

// --- Timestamps for latency profiling ---
buf->add_time_stamp("my_stage");  // marks current wall-clock time

```

--------------------------------

### Get Storage Status

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Provides a detailed breakdown of disk space usage for different components of the application.

```APIDOC
## GET /api/storage/status

### Description
Provides a detailed breakdown of disk space usage for different components of the application.

### Method
GET

### Endpoint
/api/storage/status

### Request Body
None

### Success Response (200 OK)
```json
{
  "total_space": 1000000000,
  "available_space": 20000000,
  "used_space": 80000000,
  "breakdown": {
    "database": 5000000,
    "faissdb": 100000000,
    "thumbnail": 30000000,
    "video": 7000000000
  },
  "timestamp": 1678886400000,
  "status": "success"
}
```
- All storage space field values are in bytes.
- **breakdown** (object): Contains the size of individual data directories in bytes
- **timestamp** (number): current epoch time stamp in seconds

### Error Response (When data is unavailable)
```json
{
  "total_space": "N/A",
  "available_space": "N/A",
  "used_space": "N/A",
  "breakdown": {
    "database": "N/A",
    "faissdb": "N/A",
    "thumbnail": "N/A",
    "video": "N/A"
  },
  "status": "error",
  "message": "Failed to retrieve storage info"
}
```
```

--------------------------------

### Format New Partition

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/docs/storage_partition.rst

Format the newly created partition (e.g., `/dev/mmcblk1p3`) with the ext4 filesystem. This process may take a few minutes.

```console
mkfs.ext4 /dev/mmcblk1p3
```

--------------------------------

### Install GStreamer Plugins and OpenCV

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/tools/cross_compiler/README.rst

Add these packages to your Yocto image configuration for GStreamer plugins and OpenCV requirements.

```sh
# GStreamer plugins
IMAGE_INSTALL_append += "                    \
    imx-gst1.0-plugin                        \
    gstreamer1.0-plugins-bad-videoparsersbad \
    gstreamer1.0-plugins-good-video4linux2   \
    gstreamer1.0-plugins-base                \
"

# Opencv requirements for the hailo gstreamer plugin’s postprocess
CORE_IMAGE_EXTRA_INSTALL += "    \
      libopencv-core-dev         \
      libopencv-highgui-dev      \
"

```

--------------------------------

### Show Video Modal and Initialize Playback

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/index.html

Displays a video modal, populates it with video description and timestamp, and initiates the video session and playback. Handles connection states and errors.

```javascript
async showVideoModal(videoInfo) {
    this.currentVideoInfo = videoInfo;
    document.getElementById('videoDescription').textContent = videoInfo.description;
    document.getElementById('videoTimestamp').textContent = epochToDate(videoInfo.timestamp);
    this.modal = new bootstrap.Modal(document.getElementById('videoModal'));
    this.modal.show();
    this.videoElement.style.display = 'none';
    this.videoControls.classList.remove('hidden');
    this.updateStatus('connecting');
    this.isPlaying = false;
    try {
      await this.requestVideoSession();
      this.updateStatus('connected');
      setTimeout(() => {
        this.startVideoPlayback();
      }, 500);
    } catch (error) {
      console.error('Error preparing video:', error);
      this.updateStatus('disconnected');
    }
  }
```

--------------------------------

### Main Application Logic

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/ai_example_app/docs/app_structure.rst

This C++ code demonstrates the main execution flow of the application, including argument parsing, pipeline creation, configuration, execution, and cleanup.

```cpp
                            // Stop pipeline
                            app_resources->pipeline->stop_pipeline();
                            // terminate program  
                            exit(0); 
                        });

                        // Parse user arguments
                        cxxopts::Options options = build_arg_parser();
                        auto result = options.parse(argc, argv);
                        std::vector<ArgumentType> argument_handling_results = handle_arguments(result, options);
                        int timeout  = result["timeout"].as<int>();

                        for (ArgumentType argument : argument_handling_results)
                        {
                            switch (argument)
                            {
                            case ArgumentType::Help:
                                return 0;
                            case ArgumentType::Timeout:
                                break;
                            case ArgumentType::PrintFPS:
                                app_resources->print_fps = true;
                                break;
                            case ArgumentType::PrintLatency:
                                app_resources->print_latency = true;
                                break;
                            case ArgumentType::Config:
                                app_resources->frontend_config = result["config-file-path"].as<std::string>();
                                break;
                            case ArgumentType::SkipDrawing:
                                app_resources->skip_drawing = true;
                                break;
                            case ArgumentType::PartialLandmarks:
                                app_resources->partial_landmarks = true;
                                break;
                            case ArgumentType::Error:
                                return 1;
                            }
                        }

                        // Create pipeline
                        app_resources->pipeline = std::make_shared<Pipeline>();

                        // Configure frontend and encoders
                        configure_frontend_and_encoders(app_resources);

                        // Create pipeline and stages
                        create_ai_pipeline(app_resources);

                        // Subscribe stages to frontend
                        subscribe_to_frontend(app_resources);

                        // Start pipeline
                        std::cout << "Starting." << std::endl;
                        app_resources->pipeline->start_pipeline();

                        std::cout << "Using frontend config: " << app_resources->frontend_config << std::endl;
                        std::cout << "Started playing for " << timeout << " seconds." << std::endl;

                        // Wait
                        std::this_thread::sleep_for(std::chrono::seconds(timeout));

                        // Stop pipeline
                        std::cout << "Stopping." << std::endl;
                        app_resources->pipeline->stop_pipeline();
                        app_resources->clear();
                    }
                    return 0;
                }
```

--------------------------------

### Get WebRTC Connection Status

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Periodically polled by the client to check if the server-side peer connection is still active.

```APIDOC
## GET /api/webrtc/status

### Description
Periodically polled by the client to check if the server-side peer connection is still active.

### Method
GET

### Endpoint
/api/webrtc/status

### Request Body
None

### Success Response (200 OK)
```json
{
  "connected": true
}
```
- **connected** (boolean): `true` if the server's peer connection is active, `false` otherwise.
```

--------------------------------

### Basic File Source to UDP Pipeline

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/file_source_to_udp/README.rst

This is the most basic configuration for the pipeline, requiring only the video file path, its width and height, and the encoder configuration file.

```bash
# Basic usage with required parameters
./file_source_to_udp_case_study -f video.nv12 -w 1920 -g 1080 -e encoder.json
```

```bash
# Basic usage with required parameters
./file_source_to_udp_case_study -f /path/to/video.nv12 -w 1920 -g 1080 -e /path/to/encoder.json
```

--------------------------------

### Tokenizer Vocabulary Operations

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/utils/tokenizers/README.md

Get the total vocabulary size and perform conversions between token strings and their corresponding IDs.

```cpp
// Get vocabulary size
size_t vocab_size = tokenizer->GetVocabSize();

// Convert between tokens and IDs
int32_t token_id = tokenizer->TokenToId("cat");
std::string token = tokenizer->IdToToken(token_id);
```

--------------------------------

### Host Machine GStreamer Pipeline

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/single_stream/README.rst

Run this command on the host machine to capture and display the video feed from the Hailo15 platform.

```bash
$ gst-launch-1.0 udpsrc port=5000 address=10.0.0.2 ! application/x-rtp,encoding-name=H264 ! 
queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! rtpjitterbuffer mode=0 ! 
queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! rtph264depay ! 
queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! h264parse ! avdec_h264 ! 
queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=downstream ! videoconvert n-threads=8 ! 
queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! fpsdisplaysink text-overlay=false sync=false
```

--------------------------------

### Error Response for Unavailable Extension

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Example error response when a required extension module is not available. This can occur for configuration or query-related services.

```json
{
  "error": "AppControlServiceExt extension not available"
}
```

```json
{
  "error": "ClipQueryService extension not available"
}
```

--------------------------------

### List Block Devices

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/docs/storage_partition.rst

Use `lsblk` to view the current disk and partition layout. This helps identify the main storage device (e.g., `mmcblk1`) and its existing partitions.

```console
root@hailo15:~# lsblk
NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
mtdblock0    31:0   0   32M  0 disk
mmcblk1     179:0   0   58G  0 disk
├─mmcblk1p1 179:1   0   64M  0 part /boot
└─mmcblk1p2 179:2   0  2.5G  0 part /

```

--------------------------------

### Get Query Video Playback Length

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Retrieves the total duration for video clips playback generated for the selected query results.

```APIDOC
## GET /api/config/video_playback_total_length

### Description
Retrieves the total duration for video clips playback generated for the selected query results.

### Method
GET

### Endpoint
/api/config/video_playback_total_length

### Response
#### Success Response (200 OK)
- total_length (number) - The total video playback duration in seconds.

### Response Example
```json
{
  "total_length": 15
}
```

#### Error Response (500 Internal Server Error)
- error (string) - "ClipQueryService extension not available"

### Error Response Example
```json
{
  "error": "ClipQueryService extension not available"
}
```
```

--------------------------------

### Verify New Partition After Reboot

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/docs/storage_partition.rst

After partitioning and rebooting, use `fdisk -l` to verify that the new partition (e.g., `mmcblk1p3`) has been created successfully and shows the expected size.

```console
root@hailo15:~# fdisk -l /dev/mmcblk1
Disk /dev/mmcblk1: 57.96 GiB, 62239277056 bytes, 121561088 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xcc2233d9

Device       Boot   Start       End   Sectors  Size Id Type
/dev/mmcblk1p1 *        8    131079    131072   64M  c W95 FAT32 (LBA)
/dev/mmcblk1p2      131080   5405573   5274494  2.5G 83 Linux
/dev/mmcblk1p3     5406720 121561087 116154368 55.4G 83 Linux

```

--------------------------------

### Get Image Embedding Refresh Rate

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Retrieves the current refresh rate for the tracked image embedding process in the video pipeline.

```APIDOC
## GET /api/config/embedded_refresh

### Description
Retrieves the current refresh rate for the tracked image embedding process in the video pipeline.

### Method
GET

### Endpoint
/api/config/embedded_refresh

### Response
#### Success Response (200 OK)
- rate (number) - The current refresh rate in frames per second (FPS).

### Response Example
```json
{
  "rate": 30
}
```

#### Error Response (500 Internal Server Error)
- error (string) - "AppControlServiceExt extension not available"

### Error Response Example
```json
{
  "error": "AppControlServiceExt extension not available"
}
```
```

--------------------------------

### File Source to UDP with Custom Network Settings

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/file_source_to_udp/README.rst

Configure the target IP address and UDP port for streaming the video data.

```bash
# Custom network settings
./file_source_to_udp_case_study -f video.nv12 -w 1920 -g 1080 -e encoder.json -o 192.168.1.100 -p 6000
```

--------------------------------

### Get Server Status API

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Retrieves the current status and timestamp of the web server. Use this to check basic server health.

```json
{
  "status": "ok",
  "timestamp": 1678886400000
}
```

--------------------------------

### File Source to UDP with FPS Monitoring

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/file_source_to_udp/README.rst

Enable the display of Frames Per Second (FPS) statistics during the pipeline's execution.

```bash
# Enable FPS monitoring
./file_source_to_udp_case_study -f video.nv12 -w 1920 -g 1080 -e encoder.json -s
```

--------------------------------

### Run Custom Stage Application

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/custom_stage/README.rst

Execute this command on the Hailo15 platform to run the compiled custom stage application. This will display the video feed with inference overlays and print results to the console.

```bash
$ ./apps/case_studies/custom_stage/custom_stage_case_study
```

--------------------------------

### Find GStreamer Plugin Directory

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/tools/cross_compiler/README.rst

Use this command to locate the directory where GStreamer plugins are installed. This path is needed to copy the Hailo-specific GStreamer libraries.

```sh
gst-inspect-1.0 filesrc | grep Filename | awk '{print $2}' | xargs dirname
```

--------------------------------

### Error Response for Invalid Input

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Example error response when an invalid value is provided for a configuration setting. This applies to refresh rates and video playback lengths.

```json
{
  "error": "Invalid refresh rate"
}
```

```json
{
  "error": "Invalid video playback total length"
}
```

--------------------------------

### Mount New Partition

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/docs/storage_partition.rst

Mount the newly formatted partition to a directory (e.g., `/data`). This makes the expanded storage accessible.

```console
mount /dev/mmcblk1p3 /data
```

--------------------------------

### Get WebRTC Connection Status

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Periodically polled by the client to check if the server-side peer connection is still active. Returns a boolean indicating connection status.

```json
{
  "connected": true
}
```

--------------------------------

### Get Image Embedding Refresh Rate API

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Retrieves the current refresh rate for image embedding. This value indicates frames per second (FPS).

```json
{
  "rate": 30
}
```

--------------------------------

### GStreamer Classification Pipeline with hailonet and libclassification.so

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

This pipeline demonstrates image classification using a virtual source, hailonet for inference with a MobileNet model, and a custom Hailo filter for post-processing. The output is then overlaid and streamed as raw video over UDP.

```bash
# apps/h15/gstreamer/classification/classification.sh
./apps/classification/classification.sh --show-fps

# Pipeline:
gst-launch-1.0 \
    videotestsrc ! \
    queue leaky=no max-size-buffers=5 max-size-bytes=0 max-size-time=0 ! \
    hailonet hef-path=/usr/share/hailo-models/mobilenet_v1.hef ! \
    queue leaky=no max-size-buffers=30 max-size-bytes=0 max-size-time=0 ! \
    hailofilter function-name=mobilenet_v1 \
                so-path=/usr/lib/hailo-post-processes/libclassification.so qos=false ! \
    queue leaky=no max-size-buffers=30 max-size-bytes=0 max-size-time=0 ! \
    hailooverlay ! \
    queue leaky=no max-size-buffers=30 max-size-bytes=0 max-size-time=0 ! \
    videoconvert ! video/x-raw,format=I420 ! \
    rtpvrawpay ! 'application/x-rtp,media=video,encoding-name=RAW' ! \
    fpsdisplaysink fps-update-interval=2000 \
                   video-sink='udpsink host=10.0.0.2 port=5000' sync=false
```

--------------------------------

### Get Query Video Playback Length API

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Retrieves the total duration in seconds for video clips generated for query results. The current duration is 15 seconds.

```json
{
  "total_length": 15
}
```

--------------------------------

### Send WebRTC Answer to Server

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Client sends its SDP answer back to the server to complete the WebRTC connection setup. Include the session ID and the SDP answer.

```json
{
  "session_id": "the-session-id",
  "type": "answer",
  "sdp": "v=0\r\no=- ...\r\n"
}
```

--------------------------------

### Run Detection Application on Hailo-15

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/README.rst

Execute the detection application using the provided bash script. This command initiates the application and displays detection results.

```bash
$ ./apps/detection/detection.sh
```

--------------------------------

### Create Test Pattern Video using FFmpeg

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/file_source_to_udp/README.rst

Generates a raw NV12 video file with a test pattern (colored bars) for a specified duration and resolution using FFmpeg.

```bash
# Create test pattern (colored bars)
ffmpeg -f lavfi -i testsrc=duration=10:size=1920x1080:rate=30 \
       -pix_fmt nv12 -f rawvideo test_video.nv12
```

--------------------------------

### Initialize Video Event Listeners

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/index.html

Sets up event listeners for video controls, modal interactions, and playback events. Ensures proper handling of user interactions and video lifecycle events.

```javascript
('click', (e) => { e.stopPropagation(); this.startVideoPlayback(); }); this.videoControls.addEventListener('click', (e) => { e.stopPropagation(); if (this.isPlaying) { this.stopVideoPlayback(); } }); this.closeButton.addEventListener('click', () => { this.closeModal(); }); this.videoElement.addEventListener('loadeddata', () => { this.resetFrameTimeout(); }); this.videoElement.addEventListener('timeupdate', () => { this.resetFrameTimeout(); });
```

--------------------------------

### Get Storage Status

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Provides a detailed breakdown of disk space usage for different application components. Returns total, available, and used space, along with a breakdown by directory.

```json
{
  "total_space": 1000000000,
  "available_space": 20000000,
  "used_space": 80000000,
  "breakdown": {
    "database": 5000000,
    "faissdb": 100000000,
    "thumbnail": 30000000,
    "video": 7000000000
  },
  "timestamp": 1678886400000,
  "status": "success"
}
```

```json
{
  "total_space": "N/A",
  "available_space": "N/A",
  "used_space": "N/A",
  "breakdown": {
    "database": "N/A",
    "faissdb": "N/A",
    "thumbnail": "N/A",
    "video": "N/A"
  },
  "status": "error",
  "message": "Failed to retrieve storage info"
}
```

--------------------------------

### Verify Hailo GStreamer Plugins

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/tools/cross_compiler/README.rst

After copying the necessary libraries, run these commands to ensure the Hailo GStreamer plugins are loaded correctly and no errors are reported.

```sh
gst-inspect-1.0 hailo
```

```sh
gst-inspect-1.0 hailotools
```

--------------------------------

### Create and Use a Bounded Queue in C++

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

Demonstrates creating both non-leaky (back-pressure) and leaky (real-time) queues. Use non-leaky queues to block producers when full, ensuring all data is processed. Use leaky queues to prioritize real-time performance by dropping the oldest data when full. Call flush() for graceful shutdown.

```cpp
// pipeline_infra/queue.hpp
#include "queue.hpp"

// --- Non-leaky queue (back-pressure): producer blocks when full ---
auto q = std::make_shared<Queue>("encoder_input", /*max_buffers=*/5, /*leaky=*/false);

// Producer thread
BufferPtr buf = ...; // from previous stage
q->push(buf);        // blocks until space is available

// Consumer thread
BufferPtr received = q->pop(); // blocks until a buffer is available
if (received == nullptr) {
    // queue was flushed (pipeline shutting down)
    return;
}
process(received);

// --- Leaky queue (real-time): oldest frame dropped when full ---
auto leaky_q = std::make_shared<Queue>("ai_input", /*max_buffers=*/3, /*leaky=*/true);
leaky_q->push(buf); // never blocks; drops oldest if full
// Drop count visible via leaky_q->m_drop_count for diagnostics

// --- Graceful shutdown ---
q->flush(); // clears all pending buffers and wakes any blocked pop() calls
```

--------------------------------

### Build Release Version for Hailo-15

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

Compiles the native application for Hailo-15 in release mode. Specify the toolchain path.

```bash
./tools/cross_compiler/cross_compile_native_apps.py hailo15 release /path/to/toolchain
```

--------------------------------

### Submit Query API Success Response

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/API.md

Example of a successful response when submitting a query. It includes a list of matching images with their base64 encoded JPEG data, description, timestamp, and similarity score.

```json
{
  "status": "success",
  "images": [
    {
      "jpeg_data": "data:image/jpeg;base64,...",
      "description": "a red sports car",
      "timestamp": 1678886400000,
      "score": 0.954
    }
  ]
}
```

--------------------------------

### Setup Event Listeners for UI Controls

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/new_clip/resources/webfrontend/index.html

Attaches event listeners to various form elements including the CLIP form submission, network selection, sliders for score threshold and max query, and a checkbox for text decode on device.

```javascript
function setupEventListeners() {
    document.getElementById('clipForm').addEventListener('submit', handleFormSubmit);
    document.getElementById('networkSelect').addEventListener('change', handleNetworkChange);
    document.getElementById('scoreThreshold').addEventListener('input', function(e) {
        document.getElementById('scoreThresholdValue').textContent = e.target.value;
    });
    document.getElementById('maxQuery').addEventListener('input', function(e) {
        document.getElementById('maxQueryValue').textContent = e.target.value;
    });
    document.getElementById('removeDuplicateWithin').addEventListener('input', function(e) {
        document.getElementById('removeDuplicateWithinValue').textContent = e.target.value;
    });
    document.getElementById('textDecodeOnDevice').addEventListener('change', function(e) {
        console.log('Text Decode On Device changed:', e.target.checked);
    });
}
```

--------------------------------

### Run GStreamer Streaming Pipeline on Host

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/apps/h15/native/case_studies/dynamic_privacy_mask/README.rst

Use this command on the host machine to capture and stream video feed via UDP. Ensure the IP address and port match your network configuration.

```bash
$ gst-launch-1.0 udpsrc port=5000 address=10.0.0.2 ! application/x-rtp,encoding-name=H264 ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! rtpjitterbuffer mode=0 ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! rtph264depay ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! h264parse ! avdec_h264 ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=downstream ! videoconvert n-threads=8 ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! fpsdisplaysink text-overlay=false sync=false
```

--------------------------------

### Run Detection Pipeline with GStreamer

Source: https://github.com/hailo-ai/hailo-camera-apps/blob/repo-is-archived/README.rst

This command launches a GStreamer pipeline to capture H.264 encoded video from UDP port 5000, depayloads, decodes it, and converts it for display. Ensure the host machine is on IP 10.0.0.2 and has a monitor connected.

```bash
$ gst-launch-1.0 udpsrc port=5000 address=10.0.0.2 ! application/x-rtp,encoding-name=H264 ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! 
  rtpjitterbuffer mode=0 ! queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! rtph264depay ! 
  queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=no ! h264parse ! avdec_h264 ! 
  queue max-size-buffers=30 max-size-bytes=0 max-size-time=0 leaky=downstream ! videoconvert n-threads=8 ! \n
```

--------------------------------

### Cross-compiling Native Apps for Hailo-15

Source: https://context7.com/hailo-ai/hailo-camera-apps/llms.txt

This script is used for cross-compiling native applications and the Reference Camera API for the Hailo-15 device using Meson and the Hailo-15 SDK toolchain.

```bash
# tools/cross_compiler/cross_compile_native_apps.py
```