#!/bin/bash # SPDX-License-Identifier: GPL-2.0-or-later # Copyright (C) 2018, Google Inc. # # Author: Laurent Pinchart # # ipu3-process.sh - Process raw frames with the Intel IPU3 # # The scripts makes use of the following tools, which are expected to be # found in $PATH: # # - media-ctl (from v4l-utils git://linuxtv.org/v4l-utils.git) # - raw2pnm (from nvt https://github.com/intel/nvt.git) # - yavta (from git://git.ideasonboard.org/yavta.git) imgu_entity="ipu3-imgu 0" # Locate the media device find_media_device() { local mdev for mdev in /dev/media* ; do media-ctl -d $mdev -p | grep -q "^driver[ \t]*ipu3-imgu$" && break mdev= done if [[ -z $mdev ]] ; then echo "IPU3 media device not found." >&2 exit 1 fi echo $mdev } # Configure the pipeline configure_pipeline() { local enable_3a=1 local enable_out=1 local enable_vf=1 local mode=0 # Configure the links $mediactl -r $mediactl -l "\"$imgu_entity input\":0 -> \"$imgu_entity\":0[1]" $mediactl -l "\"$imgu_entity\":2 -> \"$imgu_entity output\":0[$enable_out]" $mediactl -l "\"$imgu_entity\":3 -> \"$imgu_entity viewfinder\":0[$enable_vf]" $mediactl -l "\"$imgu_entity\":4 -> \"$imgu_entity 3a stat\":0[$enable_3a]" # Select processing mode (0 for video, 1 for still image) yavta --no-query -w "0x009819c1 $mode" $($mediactl -e "$imgu_entity") # Set formats. The media bus code doesn't matter as it is ignored by the # driver. We should use the FIXED format, but media-ctl doesn't support # it. $mediactl -V "\"$imgu_entity\":0 [fmt:SBGGR10_1X10/$out_size crop:(0,0)/$in_size compose:(0,0)/$in_size]" $mediactl -V "\"$imgu_entity\":2 [fmt:SBGGR10_1X10/$out_size]" $mediactl -V "\"$imgu_entity\":3 [fmt:SBGGR10_1X10/$vf_size]" $mediactl -V "\"$imgu_entity\":4 [fmt:SBGGR10_1X10/$out_size]" } # Perform frame processing through the IMGU process_frames() { configure_pipeline local yavta="yavta -n $nbufs -c$frame_count" # Save the main and viewfinder outputs to disk, capture and drop 3A # statistics. Sleep 500ms between each execution of yavta to keep the # stdout messages readable. $yavta -f $IMGU_OUT_PIXELFORMAT -s $out_size "-F$output_dir/frame-out-#.bin" \ $($mediactl -e "$imgu_entity output") & sleep 0.5 $yavta -f $IMGU_VF_PIXELFORMAT -s $vf_size "-F$output_dir/frame-vf-#.bin" \ $($mediactl -e "$imgu_entity viewfinder") & sleep 0.5 $yavta $($mediactl -e "$imgu_entity 3a stat") & sleep 0.5 # Feed the IMGU input. $yavta -f $IMGU_IN_PIXELFORMAT -s $in_size "-F$in_file" \ $($mediactl -e "$imgu_entity input") } # Convert captured files to ppm convert_files() { local index=$1 local type=$2 local size=$3 local format=$4 local width=$(echo $size | awk -F 'x' '{print $1}') local height=$(echo $size | awk -F 'x' '{print $2}') local padded_width=$(expr $(expr $width + 63) / 64 \* 64) raw2pnm -x$padded_width -y$height -f$format \ $output_dir/frame-$type-$index.bin \ $output_dir/frame-$type-$index.ppm } run_test() { IMGU_IN_PIXELFORMAT=IPU3_SGRBG10 IMGU_OUT_PIXELFORMAT=NV12 IMGU_VF_PIXELFORMAT=NV12 echo "==== Test ====" echo "input: $in_file" echo "output: $IMGU_OUT_PIXELFORMAT/$out_size" echo "vf: $IMGU_VF_PIXELFORMAT/$vf_size" process_frames for i in `seq -f '%06.0f' 0 $(($frame_count - 1))`; do convert_files $i out $out_size $IMGU_OUT_PIXELFORMAT convert_files $i vf $vf_size $IMGU_VF_PIXELFORMAT done } validate_size() { local size=$1 local width=$(echo $size | awk -F 'x' '{print $1}') local height=$(echo $size | awk -F 'x' '{print $2}') [[ "x${size}" == "x${width}x${height}" ]] } # Print usage message usage() { echo "Usage: $(basename $1) [options] " echo "Supported options:" echo "--out size output frame size (defaults to input size)" echo "--vf size viewfinder frame size (defaults to input size)" echo "" echo "Where the input file name and size are" echo "" echo "input-file = prefix '-' width 'x' height '.' extension" echo "size = width 'x' height" } # Parse command line arguments while (( "$#" )) ; do case $1 in --out) out_size=$2 if ! validate_size $out_size ; then echo "Invalid size '$out_size'" usage $0 exit 1 fi shift 2 ;; --vf) vf_size=$2 if ! validate_size $vf_size ; then echo "Invalid size '$vf_size'" usage $0 exit 1 fi shift 2 ;; -*) echo "Unsupported option $1" >&2 usage $0 exit 1 ;; *) break ;; esac done if [ $# != 1 ] ; then usage $0 exit 1 fi in_file=$1 # Parse the size from the input file name and perform minimal sanity # checks. in_size=$(echo $in_file | sed 's/.*-$[0-9]*$x$[0-9]*$\.[a-z0-9]*$/\1x\2/') validate_size $in_size if [[ $? != 0 ]] ; then echo "Invalid input file name $in_file" >&2 usage $0 exit 1 fi out_size=${out_size:-$in_size} vf_size=${vf_size:-$in_size} mdev=$(find_media_device) || exit mediactl="media-ctl -d $mdev" echo "Using device $mdev" output_dir="/tmp" frame_count=5 nbufs=7 run_test ='#n56'>56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2020, Google Inc.
#
# Author: Paul Elder <paul.elder@ideasonboard.com>
#
# analyze-ipa-trace.py - Example of how to extract information from libcamera lttng traces

import argparse
import bt2
import statistics as stats
import sys

# pipeline -> {function -> stack(timestamps)}
timestamps = {}

# pipeline:function -> samples[]
samples = {}

def main(argv):
    parser = argparse.ArgumentParser(
            description='A simple analysis script to get statistics on time taken for IPA calls')
    parser.add_argument('-p', '--pipeline', type=str,
                        help='Name of pipeline to filter for')
    parser.add_argument('trace_path', type=str,
                        help='Path to lttng trace (eg. ~/lttng-traces/demo-20201029-184003)')
    args = parser.parse_args(argv[1:])

    traces = bt2.TraceCollectionMessageIterator(args.trace_path)
    for msg in traces:
        if type(msg) is not bt2._EventMessageConst or \
           'pipeline_name' not in msg.event.payload_field or \
           (args.pipeline is not None and \
            msg.event.payload_field['pipeline_name'] != args.pipeline):
            continue

        pipeline = msg.event.payload_field['pipeline_name']
        event = msg.event.name
        func = msg.event.payload_field['function_name']
        timestamp_ns = msg.default_clock_snapshot.ns_from_origin

        if event == 'libcamera:ipa_call_begin':
            if pipeline not in timestamps:
                timestamps[pipeline] = {}
            if func not in timestamps[pipeline]:
                timestamps[pipeline][func] = []
            timestamps[pipeline][func].append(timestamp_ns)

        if event == 'libcamera:ipa_call_end':
            ts = timestamps[pipeline][func].pop()
            key = f'{pipeline}:{func}'
            if key not in samples:
                samples[key] = []
            samples[key].append(timestamp_ns - ts)

    # Compute stats
    rows = []
    rows.append(['pipeline:function', 'min', 'max', 'mean', 'stddev'])
    for k, v in samples.items():
        mean = int(stats.mean(v))
        stddev = int(stats.stdev(v))
        minv = min(v)
        maxv = max(v)
        rows.append([k, str(minv), str(maxv), str(mean), str(stddev)])

    # Get maximum string width for every column
    widths = []
    for i in range(len(rows[0])):
        widths.append(max([len(row[i]) for row in rows]))

    # Print stats table
    for row in rows:
        fmt = [row[i].rjust(widths[i]) for i in range(1, 5)]
        print('{} {} {} {} {}'.format(row[0].ljust(widths[0]), *fmt))

if __name__ == '__main__':
    sys.exit(main(sys.argv))