Runner/utils: Add reusable GStreamer AI/ML helper functions

Signed-off-by: Vij Patel <vijpatel@qti.qualcomm.com>

Author: vijpatel22

Runner/utils/lib_gstreamer.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 # Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
-# SPDX-License-Identifier: BSD-3-Clause
+# SPDX-License-Identifier: BSD-3-Clause#
 # Runner/utils/lib_gstreamer.sh
 #
 # GStreamer helpers.
@@ -20,77 +20,31 @@ GSTLAUNCHFLAGS="${GSTLAUNCHFLAGS:--e -v -m}"
 # GST_ALSA_PLAYBACK_DEVICE=hw:0,0
 # GST_ALSA_CAPTURE_DEVICE=hw:0,1
 
-# -------------------- Shared artifact directory (generic) --------------------
-# gstreamer_shared_artifact_dir <env_var_name> <shared_subdir> <local_subdir> <script_dir> <outdir>
-# Generic function to get shared artifact directory for any test type.
+# -------------------- Shared encoded-artifact directory --------------------
+# gstreamer_shared_encoded_dir <script_dir> <outdir>
+# Prints a directory path to use for encoded video artifacts.
 # Priority:
-# 1. Environment variable if explicitly provided (e.g., VIDEO_SHARED_ENCODE_DIR, AUDIO_SHARED_RECORDED_DIR)
+# 1. VIDEO_SHARED_ENCODE_DIR if explicitly provided
 # 2. A job-shared path derived from the common LAVA prefix before /tests/
-# 3. Fallback to <outdir>/<local_subdir> for local/manual runs
-#
-# Parameters:
-#   env_var_name: Name of environment variable to check (e.g., "VIDEO_SHARED_ENCODE_DIR")
-#   shared_subdir: Subdirectory name for shared path (e.g., "video-encode-decode", "audio-record-playback")
-#   local_subdir: Subdirectory name for local fallback (e.g., "encoded", "recorded")
-#   script_dir: Script directory path
-#   outdir: Output directory path
-#
-# Example usage:
-#   gstreamer_shared_artifact_dir "VIDEO_SHARED_ENCODE_DIR" "video-encode-decode" "encoded" "$SCRIPT_DIR" "$OUTDIR"
-#   gstreamer_shared_artifact_dir "AUDIO_SHARED_RECORDED_DIR" "audio-record-playback" "recorded" "$SCRIPT_DIR" "$OUTDIR"
-gstreamer_shared_artifact_dir() {
-    env_var_name="$1"
-    shared_subdir="$2"
-    local_subdir="$3"
-    script_dir="$4"
-    outdir="$5"
-
-    # Check if environment variable is set (using eval for dynamic variable name)
-    env_value=$(eval "printf '%s' \"\${${env_var_name}:-}\"")
-    if [ -n "$env_value" ]; then
-        printf '%s\n' "$env_value"
+# 3. Fallback to <outdir>/encoded for local/manual runs
+gstreamer_shared_encoded_dir() {
+    script_dir="$1"
+    outdir="$2"
+
+    if [ -n "${VIDEO_SHARED_ENCODE_DIR:-}" ]; then
+        printf '%s\n' "$VIDEO_SHARED_ENCODE_DIR"
         return 0
     fi
 
-    # Check if we're in a LAVA test structure (contains /tests/)
     case "$script_dir" in
         */tests/*)
-            printf '%s/shared/%s\n' "${script_dir%%/tests/*}" "$shared_subdir"
+            printf '%s/shared/video-encode-decode\n' "${script_dir%%/tests/*}"
             ;;
         *)
-            printf '%s/%s\n' "$outdir" "$local_subdir"
+            printf '%s/encoded\n' "$outdir"
             ;;
     esac
 }
-
-# -------------------- Shared encoded-artifact directory (video) --------------------
-# gstreamer_shared_encoded_dir <script_dir> <outdir>
-# Prints a directory path to use for encoded video artifacts.
-# This is a wrapper around gstreamer_shared_artifact_dir for backward compatibility.
-# Priority:
-# 1. VIDEO_SHARED_ENCODE_DIR if explicitly provided
-# 2. A job-shared path derived from the common LAVA prefix before /tests/
-# 3. Fallback to <outdir>/encoded for local/manual runs
-gstreamer_shared_encoded_dir() {
-    script_dir="$1"
-    outdir="$2"
-    
-    gstreamer_shared_artifact_dir "VIDEO_SHARED_ENCODE_DIR" "video-encode-decode" "encoded" "$script_dir" "$outdir"
-}
-
-# -------------------- Shared recorded-artifact directory (audio) --------------------
-# gstreamer_shared_recorded_dir <script_dir> <outdir>
-# Prints a directory path to use for recorded audio artifacts.
-# Priority:
-# 1. AUDIO_SHARED_RECORDED_DIR if explicitly provided
-# 2. A job-shared path derived from the common LAVA prefix before /tests/
-# 3. Fallback to <outdir>/recorded for local/manual runs
-gstreamer_shared_recorded_dir() {
-    script_dir="$1"
-    outdir="$2"
-    
-    gstreamer_shared_artifact_dir "AUDIO_SHARED_RECORDED_DIR" "audio-record-playback" "recorded" "$script_dir" "$outdir"
-}
 # -------------------- Element check --------------------
 has_element() {
   elem="$1"
@@ -1122,3 +1076,241 @@ prepare_vp9_from_local_path() {
 
   return 1
 }
+# --------------------------------------------------------------
+# download_resource
+#   $1  url   – URL to download
+#   $2  dest  – Either a file name or an existing directory.
+#   Prints the full path of the downloaded file on stdout.
+# --------------------------------------------------------------
+download_resource() {
+    url=$1
+    dest=$2
+
+    if [ -d "${dest}" ]; then
+        filename=$(basename "${url}")
+        dest="${dest%/}/${filename}"
+    fi
+
+    # Check if file already exists and is non-empty
+    if [ -f "${dest}" ] && [ -s "${dest}" ]; then
+        if command -v realpath >/dev/null 2>&1; then
+            realpath "${dest}"
+        else
+            case "${dest}" in
+                ./*) echo "${dest#./}" ;;
+                *)   echo "${dest}" ;;
+            esac
+        fi
+        return 0
+    fi
+    if command -v ensure_network_online >/dev/null 2>&1; then
+        if ! ensure_network_online; then
+            echo "Network offline/limited; cannot fetch assets"
+            return 1
+        fi
+    fi
+
+    mkdir -p "$(dirname "${dest}")"
+    if command -v curl >/dev/null 2>&1; then
+        curl -fkL "${url}" -o "${dest}" || { echo "Error: curl failed to download ${url}" >&2; return 1; }
+    elif command -v wget >/dev/null 2>&1; then
+        wget -q "${url}" -O "${dest}" || { echo "Error: wget failed to download ${url}" >&2; return 1; }
+    else
+        echo "Error: neither 'curl' nor 'wget' is installed." >&2
+        return 1
+    fi
+
+    # Verify successful download with non-empty file
+    if [ ! -s "${dest}" ]; then
+        echo "Error: downloaded file is empty: ${dest}" >&2
+        return 1
+    fi
+
+    if command -v realpath >/dev/null 2>&1; then
+        realpath "${dest}"
+    else
+        case "${dest}" in
+        ./*) echo "${dest#./}" ;;
+        *)   echo "${dest}" ;;
+        esac
+    fi
+}
+# --------------------------------------------------------------
+# extract_zip_to_dir
+# --------------------------------------------------------------
+extract_zip_to_dir() {
+    zip_path=$1
+    dest_dir=$2
+
+    mkdir -p "${dest_dir}"
+    if ! unzip -o "${zip_path}" -d "${dest_dir}" >/dev/null; then
+        echo "Unzip of ${zip_path} failed" >&2
+        return 1
+    fi
+}
+# -------------------------------------------------------------------------
+# check_pipeline_elements <pipeline-string>
+#   Verify that every GStreamer element that appears in a gst-launch
+#   pipeline is installed on the system (via `has_element`).
+#   Returns:
+#       0 – all elements are present
+#       1 – at least one element is missing
+# -------------------------------------------------------------------------
+check_pipeline_elements() {
+    pipeline="${1:?missing pipeline argument}"
+    missing_count=0
+    missing_list=""
+    total_elements=0
+
+    log_info "Checking elements in pipeline"
+
+    # ---------------------------------------------------------
+    # Normalise the pipeline string
+    # ---------------------------------------------------------
+    pipeline=$(printf '%s' "$pipeline" | tr -d '\\\n')
+    pipeline=${pipeline#gst-launch-1.0* }
+    #   Remove the literal "gst-launch-1.0" if present
+    pipeline=${pipeline#gst-launch-1.0}
+    #   Trim any leading whitespace left by the previous step
+    pipeline=${pipeline#"${pipeline%%[![:space:]]*}"}
+    #   Drop leading option tokens (e.g. "-e", "-v", "--no-fault")
+    while [ "${pipeline#-}" != "$pipeline" ]; do
+        #   Remove the first token (option) and any following whitespace
+        pipeline=${pipeline#* }
+        pipeline=${pipeline#"${pipeline%%[![:space:]]*}"}
+    done
+
+    # ---------------------------------------------------------
+    # Write the token list to a temporary file
+    # ---------------------------------------------------------
+    tmpfile=$(mktemp)
+    printf '%s' "$pipeline" | tr '!' '\n' >"$tmpfile"
+
+    # ---------------------------------------------------------
+    # Read the file line‑by‑line – this runs in the *current*
+    #    shell, so variable updates survive.
+    # ---------------------------------------------------------
+    while IFS= read -r element_spec; do
+        # ---- NEW ----
+        # Strip surrounding whitespace; skip blank lines
+        # element_spec=$(printf '%s' "$element_spec" | xargs)
+        element_spec=$(printf '%s\n' "$element_spec" | awk '{$1=$1; print}')
+        [ -z "$element_spec" ] && continue
+        # --------------
+
+        element_name=$(printf '%s' "$element_spec" | cut -d' ' -f1)
+
+        case "$element_name" in
+            *.)               log_info "Skipping element reference: $element_name" ; continue ;;
+            name=*)           log_info "Skipping property assignment: $element_name" ; continue ;;
+            *_::*)            log_info "Skipping property assignment: $element_name" ; continue ;;
+            video/*|audio/*|application/*|text/*|image/*)
+                            log_info "Skipping caps filter: $element_name" ; continue ;;
+            *)
+                total_elements=$(( total_elements + 1 ))
+                if ! has_element "$element_name"; then
+                    missing_count=$(( missing_count + 1 ))
+                    missing_list="${missing_list}${element_name} "
+                    log_error "Required element missing: $element_name"
+                fi
+                ;;
+        esac
+    done <"$tmpfile"
+    # Clean up the temporary file
+    rm -f "$tmpfile"
+
+    if [ "$missing_count" -eq 0 ]; then
+        log_pass "All $total_elements elements in pipeline are available"
+        return 0
+    else
+        log_fail "Missing $missing_count/$total_elements elements: $missing_list"
+        return 1
+    fi
+}
+# ----------------------------------------------------------------------
+#  Run a pipeline with timeout, capture console output and GST debug logs.
+# ----------------------------------------------------------------------
+run_pipeline_with_logs() {
+    name=$1
+    cmd=$2
+    logdir=${3:-logs}
+    TIMEOUT=${4:-60} # default 60 seconds
+
+    console_log="${logdir}/${name}_console.log"
+    gst_debug_log="${logdir}/${name}_gst_debug.log"
+
+    export GST_DEBUG_FILE="${gst_debug_log}"
+
+    log_info "Running ${name} (timeout=${TIMEOUT}s)"
+    gstreamer_run_gstlaunch_timeout "$TIMEOUT" "$cmd" >"$console_log" 2>&1
+    rc=$?
+
+    # Look for a successful PLAYING state and the absence of ERROR messages.
+    playing=$(grep -c "Setting pipeline to PLAYING" "$console_log" || true)
+    error_present=$(grep -c "ERROR:" "$console_log" || true)
+
+    if [ "$playing" -gt 0 ] && [ "$error_present" -eq 0 ]; then
+        log_pass "${name} PASS"
+        return 0
+    fi
+
+    # Special case: timeout (rc = 124) but PLAYING was already reached.
+    if [ "$rc" -eq 124 ] && [ "$playing" -gt 0 ]; then
+        log_pass "${name} PASS (completed before timeout)"
+        return 0
+    fi
+
+    # Anything else is a failure.
+    log_fail "${name} FAIL (rc=${rc})"
+    log_info "=== ERROR DETAILS ==="
+    if [ "$error_present" -gt 0 ]; then
+        grep -A10 -B5 "ERROR:" "$console_log" | tail -n 30 |
+            while IFS= read -r line; do log_info "$line"; done
+    else
+        tail -n 30 "$console_log" |
+            while IFS= read -r line; do log_info "$line"; done
+    fi
+    log_info "====================="
+    return 1
+}
+# ------------------------------------------------------------------
+# Function:  check_file_size
+# Purpose :  Check that a file exists and its size > 0.
+# Returns :  0  → file size > 0 (success)
+#            1  → file missing, unreadable, or size == 0 (failure)
+# Requires:  GNU coreutils (stat -c %s)
+# ------------------------------------------------------------------
+check_file_size() {
+  input_file_path="$1"
+  expected_file_size="$2"
+
+  if [ -z "$input_file_path" ]; then
+      log_fail "No input file path provided"
+      return 1
+  fi
+  if [ ! -e "$input_file_path" ]; then
+      log_fail "Encoded video file does not exist: $input_file_path"
+      return 1
+  fi
+
+    # ---- Ensure we have `stat` ------------------------------------------------
+    if ! command -v stat >/dev/null 2>&1; then
+        log_fail "stat command not found – cannot determine file size"
+        return 1
+    fi
+
+    # ---- Get the actual size -------------------------------------------------
+    size_in_bytes=$(stat -c %s "$input_file_path" 2>/dev/null || wc -c <"$input_file_path" 2>/dev/null) || {
+        log_fail "Unable to read size of file: $input_file_path"
+        return 1
+    }
+
+    # ---- Compare with the expected size --------------------------------------
+    if [ "$size_in_bytes" -ge "$expected_file_size" ]; then
+        log_pass "File OK (size ${size_in_bytes} bytes ≥ ${expected_file_size} bytes): $input_file_path"
+        return 0
+    else
+        log_info "File too small (size ${size_in_bytes} bytes < ${expected_file_size} bytes): $input_file_path"
+        return 1
+    fi
+}