utils/ipu3/ipu3-process.sh


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

#!/bin/bash
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2018, Google Inc.
#
# Author: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
#
# 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] <input-file>"
	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"