Kuba Kodzi

https://git.kuba-orlik.name/kuba/qml-process

Osadzanie customowych binarek być może zadziała w ten sposób:

https://stackoverflow.com/a/15099666

cd ~/Downloads
git clone https://github.com/GNOME/adwaita-icon-theme.git
cd adwaita-icon-theme
git checkout 52c34cbbe
cp Adwaita ~/.local/share/icons/Adwaita-retro

cat << EOF  > ~/.local/share/icons/Adwaita-retro/index.theme
[Icon Theme]
Name=Adwaita-retro
Comment=The Only One
Example=folder
EOF

Skrypt daje GUI do wyboru urządzeń i opcję oglądania nagrywanego streamu na żywo (z dźwiękiem lub bez; opcja bez dźwięku ma mniejsze lagi).

Enkoduje do pliku z nazwą w której jest data i godzina. Enkodowanie jest przyspieszane sprzętowo za pomocą vaapi (testowane tylko na intelu).

#!/bin/bash -x

dialog_size="--width=500 --height=500"
settings_file="/home/kuba/bin/capture-settings.conf"

last_settings=$(cat "$settings_file")
if zenity --question --text="Use previous settings: $last_settings?";
then
  audio_stream=$(echo $last_settings | awk "-F ::: " '{print $1}')
  video_device=$(echo $last_settings | awk "-F ::: " '{print $2}')
  video_format=$(echo $last_settings | awk "-F ::: " '{print $3}')
  mbps=$(echo $last_settings | awk "-F ::: " '{print $4}')
  playback_audio=$(echo $last_settings | awk "-F ::: " '{print $5}')
  echo $audio_stream $video_device $video_format $mps
else
  audio_stream=$(pactl list sources | grep -A 14 'Source ' | grep -E '(Description|Monitor of Sink|Name)' | sed -E 's/\t[a-zA-Z ]+: //' | zenity --width=1200 --height=400 --list --column=name --column=Description "--column=Monitor Of")
  video_device=$(ls -1 /dev/video* | xargs -I {} bash -c "v4l2-ctl --device {} --info | grep --extended-regexp \"(Model|Card type)\" | awk -F: '{print \$2}' | awk '{print \"{}\" \",\" \$0}' | tr , '\n'" | zenity --list --column=device --column=name $dialog_size)
  formats=$(env TERM=dumb SHELL=/bin/bash ffplay -f video4linux2 -list_formats all $video_device 2>&1)
  video_format=$(echo "$formats" | grep video4linux2 | tr "\r" "\n" | grep -v 0/0 | awk -F" : " '{print $2 "," $3 "," $4}' | tr "," "\n" | sed -E 's/[ ]+/ /g' | zenity --list  --column=name --column=space --column=framesize $dialog_size | sed 's/ //g')
  mbps=$(zenity --scale --min-value=5 --max-value=100 --value=100 "--text=Mbps for video")
  playback_audio=$(zenity --question --text "Playback audio" && echo playback_yes || echo playback_no)
fi

settings="$audio_stream ::: $video_device ::: $video_format ::: $mbps ::: $playback_audio"
echo "$settings" > "$settings_file"

if [ $playback_audio = "playback_yes" ]; then
  audio_map="";
else
  audio_map="-an -fflags nobuffer";
fi


ffmpeg -hide_banner -loglevel error -vaapi_device /dev/dri/renderD128 \
        -f video4linux2 \
        -input_format "$video_format" \
        -thread_queue_size 512 \
        -i "$video_device" \
        -f pulse \
        -thread_queue_size 512 \
        -i "$audio_stream" \
        -vf 'format=nv12,hwupload' \
        -c:v h264_vaapi \
        -b:v "${mbps}M" \
        -f mp4 "$(date +%Y-%m-%d__%H_%M__%S).mp4" \
        -fflags nobuffer \
        -f nut -c copy $audio_map pipe:1 \
   | ffplay \
       -infbuf \
       -analyzeduration 0 \
       -loglevel debug \
       -f nut -

Zwiększenie ilości RAM-u dla GPU w /boot/config.txt pomogło:

gpu_mem=256

Warto dodać też:

dtoverlay=vc4-kms-v3d

yay linux-header
sudo modprobe v4l2loopback

ls -1 /sys/devices/virtual/video4linux # sprawdzamy które urządzenie jest wirtualne

ffmpeg -f v4l2 -framerate 25 -pix_fmt nv12 -i /dev/video0 -f v4l2 -vcodec rawvideo -vf scale=-1:720 /dev/video6

Bardziej zaawansowany skrypt, z elementami GUI:

Uwaga! Wymaga v4l2-loopback-git z AUR

#!/bin/zsh -x

if [ ! -d /sys/devices/virtual/video4linux ] || [ $(ls -1 /sys/devices/virtual/video4linux | wc -l) -eq 0 ]; then
  sudo modprobe v4l2loopback  #exclusive_caps=1 "card_label=UVC Camera 2"
fi

DEVICE_NO=19

int_handler()
{
  sudo v4l2loopback-ctl delete $DEVICE_NO
  echo EXITING;
  exit 1;
}

trap 'int_handler' INT


vdev=$(ls -1 /sys/devices/virtual/video4linux | head -n 1 | sed 's/\n//') # sprawdzamy które urządzenie jest wirtualne
dev=$(~/bin/pick-video-device.sh)
resolution=$(echo "1080p\n1920:1080\n720p\n1280:720\n480p\n853:480\n234p\n416:234" | zenity --list --column=resolution --column=resolution-value --hide-column=2 --print-column=2)
width=$(echo $resolution | awk -F: '{print $1}')
height=$(echo $resolution | awk -F: '{print $2}')

sudo v4l2loopback-ctl add \
     -n "loopy doopy ${DEVICE_NO} ${height}p" \
     -w $width \
     -h $height \
     -x 1 \
     -v \
     /dev/video$DEVICE_NO

sudo v4l2loopback-ctl set-caps /dev/video$DEVICE_NO YU12:${width}x${height}@25

#ffmpeg -f v4l2 -framerate 25 -pix_fmt nv12 -i $dev -f v4l2 -vcodec rawvideo -vf "scale=-1:480" /dev/$vdev

# this worked: 
ffmpeg -f v4l2 -pix_fmt nv12 -i $dev -f v4l2 -vf "scale=$resolution,format=yuv420p" /dev/video$DEVICE_NO

Był wyłączony systemd-resolved.service

Dodatkowo, /etc/resolv.conf nie był symlinkiem do ustawień systemd-resolved. Za https://wiki.archlinux.org/title/Systemd-resolved#DNS:

ln -rsf /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf

https://qasimk.io/2018/single-application-vpn/

Ustaw VPN za pomocą openvpn. powinien się utworzyć interfejs np. tun0.

Utwórz plik /root/netns.sh:

# create the namespace                                                                                                                                                                                             
ip netns add nordvpn                                                                                                                                                                                               
                                                                                                                                                                                                                   
run_namespace="ip netns exec nordvpn"                                                                                                                                                                              
                                                                                                                                                                                                                   
$run_namespace ip link set lo up                                                                                                                                                                                   
                                                                                                                                                                                                                   
# get the ipv4 address of the device in vpn and the vpn gateway                                                                                                                                                    
IP_4=$(ip a | grep -A 5 tun0 | grep "inet " | awk '{print $2}')                                                                                                                                                    
VPN_GATEWAY=$(ip r | grep tun0 | grep via | head -n 1 | awk '{print $3"/"32}')                                                                                                                                     
                                                                                                                                                                                                                   
# transfer the tun0 into the namespace                                                                                                                                                                             
ip link set tun0 netns nordvpn                                                                                                                                                                                     
# up the interface                                                                                                                                                                                                 
$run_namespace ip link set tun0 up                                                                                                                                                                                 
# set the proper address for the tun0 after transfer                                                                                                                                                               
$run_namespace ip addr add $IP_4 peer $VPN_GATEWAY dev tun0                                                                                                                                                        
$run_namespace ip route add default dev tun0                                                                                                                                                                       
                                                                                                                                                                                                                   
                                                                                                                                                                                                                   
# set a bridge to local network so it's possible to communicate with transmission                                                                                                                                  
                                                                                                                                                                                                                   
ip link add vpn0 type veth peer name vpn1                                                                                                                                                                          
ip link set vpn0 up                                                                                                                                                                                                
ip link set vpn1 netns nordvpn up                                                                                                                                                                                  
                                                                                                                                                                                                                   
ip addr add 10.200.200.1/24 dev vpn0                                                                                                                                                                               
ip netns exec nordvpn ip addr add 10.200.200.2/24 dev vpn1                                                                                                                                                         
ip netns exec nordvpn ip route add 192.168.0.0/24 via 10.200.200.1 dev vpn1 # local network                                                                                                                        
iptables -A INPUT \! -i vpn0 -s 10.200.200.0/24 -j DROP                                                                                                                                                            
iptables -t nat -A POSTROUTING -s 10.200.200.0/24 -o wl+ -j MASQUERADE                                                                                                                                             
                                                                                                                                                                                                                   
# forward ports for the webadmin panel                                                                                                                                                                             
iptables -t nat -A PREROUTING -p tcp --dport 9091 -j DNAT --to-destination 10.200.200.2:9091                                                                                                                       
iptables -t nat -A POSTROUTING -p tcp --dport 9091 -j MASQUERADE                                                                                                                                                   
                                                                                                                                                                                                                   
sysctl -q net.ipv4.ip_forward=1                                                                                                                                                                                    
                                                                                                                                                                                                                   
$run_namespace ip r                                                                                                                                                                                                
$run_namespace curl ifconfig.co                                                                                                                                                                                    
$run_namespace ping 192.168.0.13       

Utwórz plik /etc/systemd/system/netns-nordvpn.service:

[Unit]                                                                                                                                                                                                             
Description=Create a nordvpn ip namespace                                                                                                                                                                          
Requires=openvpn-client@nordvpn.service                                                                                                                                                                            
                                                                                                                                                                                                                   
[Service]                                                                                                                                                                                                          
Type=oneshot                                                                                                                                                                                                       
RemainAfterExit=yes                                                                                                                                                                                                
ExecStart=/root/netns.sh                                                                                                                                                                                  
                                                                                                                                                                                                                   
[Install]                                                                                                                                                                                                          
WantedBy=multi-user.target 

Utwórz plik /etc/systemd/system/namespaced-transmission.service:

[Unit]
Description=Transmission BitTorrent Daemon
After=network.target openvpn@nordvpn.service
Requires=netns-nordvpn.service
Alias=transmission.service

[Service]
Type=simple
#NetworkNamespacePath=/var/run/netns/nordvpn
ExecStart=ip netns exec nordvpn sudo -u debian-transmission /usr/bin/transmission-daemon -f --log-error
ExecStop=/bin/kill -s STOP $MAINPID
ExecReload=/bin/kill -s HUP $MAINPID

[Install]
WantedBy=multi-user.target

następnie:

sudo systemctl enable nordvpn-ns-gateway.service
sudo systemctl enable namespaced-transmission
sudo setcap 'cap_net_admin,cap_net_raw+ep' $(which transmission-daemon)

Domyślnie tylko user root ma uprawnienia do dostępu do urządzenia tworzonego przez libcec (bodajże jest to /dev/cec).

Gdy kodi nie jest odpalane jako root, to nie ma dostępu do tego pilota i rzuca błąd na starcie.

Aby to naprawić, trzeba dodać do użytkownika, który będzie odpalać kodi grupy video, lock oraz uucp:

sudo usermod -a -G video pi
sudo usermod -a -G lock pi
sudo usermod -a -G uucp pi

Najłatwiej jest to zrobić za pomocą Delgue, które ma tę funkcję wbudowaną

  1. Pobrać rbedit
  2. ./rbedit-linux-amd64 put --input publish.sh.torrent --inplace --json "[\"https://up.kuba-orlik.name/pliki/qt-creator-android.ova\"]" url-list