vdr-transcode

#!/bin/bash

# vdr-transcode				jsffm@web.de

# https://github.com/jsffm/vdr-transcode

# $Id$

# 2022-02-07

# take pid from input (vdr only)
# rm /tmp/vt
# -qv	testing

# blancs in filename	Frank Kaiser <frank.kaiser@fuxbau.net>

# ifmt	input extension
# odir
# marker
# vcodec ?
# ivcodec input vcodec
# OUTPUT
# $(nproc)
# opus_br 2ch kbit
# service_name
# h264_level	automatic ?
# -strict experimental
# echo $USER
# id -g -n <user>
# -vb
# -ab
#
# Todo:
#
# $preset
# x265_preset
# number of reference frames?
# Missing reference picture?
# reference picture missing?
# unref short failure?
# timestamp discontinuity
# local
# info series detect
# grep | tail -> grep -m
# -qscale
# -aq q
# dvb_subtitle	-canvas_size ?
# delogo
# -ar

# [mp4 @ 0x7fffce613640] opus in MP4 support is experimental, add '-strict -2' if you want to use it.

#exec > trace.log 2>&1
#set -x

os=$(uname)
numfmt=numfmt
[ "$os" == "FreeBSD" ] && numfmt=gnumfmt # coreutils
date=date
[ "$os" == "FreeBSD" ] && date=gdate
OUTPUT=vdr
INPUT=vdr
h264=copy
#h264=hevc
hevc=copy
#mpeg2=copy
mpeg2=h264
mpeg4=copy
#mpeg4=h264
mpeg4_b=1200k
vp8=copy
vp9=copy
av1=copy
vc1=copy
ac3=copy
#ac3_stereo=aac
eac3=copy
aac=copy
#mp2=copy
mp2=aac
mp3=copy
#mp3=aac
mp3_b="-b:a 128k"
dts=copy
opus=copy
pcm=aac
#crf=21
#hevc_cq=28
gq=30		# VP8
#[ -e /dev/dri/renderD128 ] && gq=120
mjpeg=0
gop_vdr_w=50
gop_vdr="-g $gop_vdr_w"

#h264_level=3.0  # 720x576i
#h264_level=4.1
#h264_level=4.2
#hevc_level=4.0
x264_preset=fast
h264_profile=high
#h264_profile=main
#hevc_level=4.1
hevc_profile=main
h264enc=libx264
#h264enc="h264_nvenc"
hevcenc=libx265
#hevcenc="hevc_nvenc"
nvenc_preset=medium
#nvenc_rc=constqp
nvenc_rc=vbr
av1enc=libsvtav1		# librav1e libaom-av1
#qav1=50
#av1preset=8
gpu=0
#deinterlace="-filter:v yadif"
deinterlace="yadif"
#deinterlace="-vf yadif_cuda"
#hwaccel=cuvid
#OPT_G="-hwaccel cuvid"
dnorm="-21"
aac_stereo_br=96k
ac3_stereo_level=192
aac_6ch_br=256k
opus_br=64 # 2ch kbit
skip=10
marks_mkv=0
chapt_marks=0
rt_port=5000
dialog=0
bitrate=0
chk_error=1
dur2sa=0

#aaclib="libfaac"
#aaclib="libfdk_aac" # Fraunhofer Library - bessere Qualität
aaclib=aac

t=/tmp/vt
old=/tmp/vt-old
vtlog=/tmp/vt-log
conf1=$(realpath $0)".conf"
conf=/etc/vdr-transcode.conf
confs=/etc/vdr-transcode-s.conf
vtc=vt.conf
lck=vt.lck
ffmpeg=ffmpeg
ffprobe=ffprobe
declare -a lang
declare -a langa
declare -a chan_sel
declare -a chan_sel_id
chan_sel_i=0
declare -a chan_set
declare -a chan_set_id
chan_set_i=0
declare -a title_set
declare -a title_set_id
title_set_i=0
declare -a volumea
declare -a dispa
declare -a dsura

log=vdr-transcode.log
logs=/var/log/vdr-transcode.log
runs=/var/run/vt_server.pid
runvt=/var/run/vt.pid
runvtf=/var/run/vtf.pid
runrts=/var/run/vt_rts.pid
rtlog=/tmp/rt_log
t_stat=/tmp/vt-stat
if [ "$USER" != "root" ]
then
    mkdir -p ~/vdr-transcode
    logs=~/vdr-transcode/vdr-transcode.log
    runs=~/vdr-transcode/vt_server.pid
    runvt=~/vdr-transcode/vt.pid
fi


#exit

help_Input() {
    echo "Input"
    echo " -i <file[+file2]>|vdr|dvd[:<track>]|<http> # default vdr"
    echo " -dvd <path>"
    echo " -dvdvideo 1   # -f dvdvideo"
    echo " -BD <path>    # AVCHD"
    echo " -tr <track>   # DVD or AVCHD track"
    echo " -va <seconds> # add video at end, only ts"
    echo " -ia <file>|<http> # second audio source, multiple calls supported"
    echo " -ic <file>        # copy chapters from an other file"
}

help_Output() {
    echo "Output"
    echo " -o vdr|mp4|mkv|webm|ts|mp3|wav # default vdr"
    echo " -t <n>       # length in seconds"
    echo " -ss <position>"
    echo " -to <position>"
    echo " --streams"
    echo " --inf"
    echo " --stat       # status"
    echo " --diag"
    echo " --p          # streams preview"
    echo "              # answer n=cancel, a=add vt.conf incl. paramters"
    echo " -copy|-cp    # copy for every track"
}

help_Video() {
    echo "Video"
    echo " -vc|-vcodec <codec> # Video Codec copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -r <n>           # fps, only when needed"
    echo " -vf <filter>     # video filter"
    echo " -maxr <fps>      # max bitrate"
    echo " -crop <w:h>"
    echo " --LB             # -vf crop=iw:ih/4*3 -aspect 16:9"
    echo " -zoom <factor>   # crop=iw/<factor>:ih/<factor>"
    echo " -scale <w:h>|hd720|hd1080|qhd|pal"
    echo " -aspect <aspect> # 16:9|4:3"
    echo " --nohw           # no hardwaredecoding"
    #echo " -b <n>           # constant bitrate for mp3, h264_omx"
    echo " -vb <n>          # constant bitrate for h264_omx"
    echo " -vq|-qv <n>      # video quality"
    echo " --chk_error      # for already transcoded with older version"
    echo " -fps_mode <param> # passthrough|cfr|vfr|auto"
}

help_Audio() {
    echo "Audio"
    echo " -ac|-acodec [<str>=]<codec> # Audio Codec copy|ac3|eac3|aac|aac_he|aac_he_v2|opus"
    echo " -sel [<file>:]<n[-n][,n]>   # audio, subtitle stream select"
    echo " -sell lang1[,lang2]...      # select for language"
    echo " --selb           # select best audio track"
    echo " --sel_eac3       # select eac3"
    echo " -vol [<str>=]<factor>    # Volume"
    #echo " -b <n>           # constant bitrate for mp3, h264_omx"
    echo " -ab [<str>=]<br>         # bitrate for mp3, aac_stereo"
    echo " -ar <sampling frequency> # audio sampling frequency"
    echo " -lang <str[-str]>=<lang>[,<str[-str]>=<lang>]"
    echo " -stro <str>=<ostr>[,<str>=<ostr>] # Streamorder"
    echo "       Sample: -stro 1=2,2=1 this should be a seperate step"
    echo " -disp <str>=default|0[,...]       # -disposition <param>"
    echo " -def <lang>                       # -disposition defaut @ <lang>"
    echo " -ch 2                             # 5.1 -> stereo"
    echo " -dsur [<str>=]2                   # mark as Dolby Surround Encoded ac3, eac3"
    echo " --dpl                             # -dsur 2 -acodec eac3"
    echo " -dpl <str>                        # -dsur <str>=2 -acodec <str>=eac3"
    echo " -skip <n> # default 10, inf() and analyze(): skip first <n> seconds"
}

help_Automation() {
    echo "Automation"
    echo " --as &             # server start, search pathes in /etc/vdr-transcode-s.conf"
    echo " --ak               # server stop"
    echo " --conf [parameter] # mark for processing"
    echo " --confr [parameter] # mark recursiv gt min_bitrate"
    echo " -confr <min_br> [parameter] # mark recursiv gt min_bitrate"
    echo " -min_br <min_br>"
    echo " -confsz <min_size>[M|G] [parameter] # find recursiv gt min_size for marking"
    echo " --alog             # process log"
    echo " --aq               # process queue"
    echo " --ac               # check processed"
    echo " --ardy             # check for lost transcodings"
    echo " --rmdel            # deletes processed records, marked to delete, use on your own risk"
    echo " --astat            # show status like out_stat"
    echo "                    # s=stat, l=log, q=quiet, h=halt, x=exit"
    echo " --aplay            # like --ac with play"
    echo " --a_conf           # show active dirs (/etc/vdr-transcode-s.conf)"
}

help_Configuration() {
    echo "Configuration /etc/vdr-transcode.conf"
    help_Configuration_V
    help_Configuration_A
    echo " other"
    echo " -o vdr|mp4|mkv|ts|mp3 # default vdr"
    echo " --out_stat            # alternate output on screen"
    echo " -out_stat log|stat    # alternate output on screen"
    echo "                       # s=stat, l=log, q=quiet, h=halt, p=suspend, r=resume"
    echo " -dialog 1             # status output by dialog"
    echo " -dvdvideo 1           # -f dvdvideo"
    echo " -vdr <path_to_vdr_dir>"
    echo " -ffpath <ffmpeg_dir>"
    echo " -ffmpeg <path_to_ffmpeg>    # deprecated, use -ffpath"
    echo " -ffprobe <path_to_ffprobe>  # deprecated, use -ffpath"
    echo " -mark <mark>                # mark at the end of transcoded recordings"
    echo " -odir <path>                # output directory"
    echo " -probesize <n>              # probesize"
    echo " -analyzeduration <n>"
    echo " --dold                      # for output file (mp4 etc) set date of old file for new file"
    echo " -marks_mkv 0|1              # marks -> chapter"
    echo " -chapt_marks 0|1|logfile    # Chapters -> marks"
    echo " -postproc <myscript>        # p1 = destpath, p2 = newcodec"
    echo "No longer needed:" 
    echo " -pid_dir <pid_path>         # default /var/run"
    echo "                             # for run as user use e.g. ~"
    echo " -server_pid <pid_file>      # default /var/run/vt_server.pid"
    echo "                             # for run as user use e.g. ~/vt_server.pid"
    echo "                             # deprecated, use -pid_dir"
    echo " -server_log <log_file>      # default /var/log/vdr-transcode.log"
    echo "                             # for run as user use e.g. ~/vdr-transcode.log"
}

help_Configuration_V() {
    #echo " video"
    echo " video configuration"
    echo " -chk_error 0|1       # Check on msg Packet corrupt"
    echo " -h264 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -h264_HD <codec>     # HD only"
    echo " -h264_br_g <bitrate> # set <codec> from -h264_HD if bitrate is higher"
    echo " -hevc copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -mpeg2 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -mpeg4 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -vc1 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -vp8 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -vp9 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -av1 copy|h264|hevc|vp8|vp9|mpeg2"
    echo " -g <n>           # goplength default 50"
    echo " -h264_q|-crf <n> # quality h264 default 21, < better, > smaller"
    echo "                    for h264_nvenc default 32"
    echo " -quality <n>     # vaapi h264 quality"
    echo " -hevc_q|-cq <n>  # quality hevc default 28, < better, > smaller"
    echo "                    for hevc_nvenc default 36"
    echo " -hevcenc hevc_nvenc|hevc_vaapi|hevc_qsv|libx265|libkvazaar"
    echo " -hevc_level <level>"
    echo " -hevc_profile <profile>     # main|main10"
    echo " -hevc_preset <preset>       # if you know, what you are doing"
    echo " -hevc_vaapi_preset \"par1 par2 etc\" # replaces every parameter"
    echo " -hevc_qsv_preset \"par1 par2 etc\"   # replaces every parameter"
    echo " -libx265_preset \"par1 par2 etc\"    # replaces every parameter"
    echo " -vp9_q|-gq <n>   # quality vp8/9 default 30, < better, > smaller"
    echo "                    for vp9_vaapi try 120"
    echo " -h264enc libx264|h264_nvenc|h264_vaapi|h264_qsv|h264_omx"
    echo " -h264_level <level>"
    echo " -h264_profile <profile>     # main|high"
    echo " -x264_preset <preset>       # default fast"
    echo " -x265_preset <preset>       # default ultrafast"
    echo " -tier <tier>                # main|high"
    echo " -h264_br         # bitrate for h264_omx, -b works too"
    echo " -b_ref_mode <int>           # hevc_nvenc, 0=disabled, 1=each, 2=middle"
    echo " -nvenc_preset <preset>      # default medium"
    echo " -nvenc_rc vbr|constqp       # default vbr"
    echo " -vp9enc libvpx-vp9|vp9_vaapi|vp9_qsv"
    echo " -av1enc libsvtav1|av1_qsv|librav1e|libaom-av1 # default libsvtav1"
    echo " -av1_q <n>                  # default 50"
    echo " -av1_preset <n>             # default 8"
    echo " -pix_fmt <pix_fmt>          # e.g. yuv420p"
    echo " -hwaccel cuvid|cuda|vaapi|qsv|vdpau|vulkan|-"
    echo " -libva i965|iHD|radeonsi"
    echo " -gpu <n>                    # vaapi qsv"
    echo " -m4_b                       # mpeg4 bitrate"
    echo " -deint_mode =mode=1"
}

help_Configuration_A() {
    echo " audio configuration"
    echo " -aac <acodec>"
    echo " -aac_6 <acodec>     # only 6ch"
    echo " -ac3 <acodec>"
    echo " -ac3_stereo aac|aac_he|eac3|-"
    echo " -ac3_stereo_level <level>      # Standard 192"
    echo " -eac3 <acodec>"
    echo " -dts <acodec>"
    echo " -mp2 <acodec>"
    echo " -mp2_128 <acodec>   # mp2 with 128kb/s"
    echo " -mp3 <acodec>"
    echo " -opus <acodec>"
    echo " -pcm <acodec>"
    echo " -dnorm <-31 .. -1>  # ac3, eac3 -dialnorm"
    echo " -aac_stereo_br|-aac_br <br> # default 96k"
    echo " -aac_6ch_br <br>    # default 256k"
    echo " -aac_vbr <1-5>      # experimental"
    echo " -aaclib aac|libfdk_aac|libfaac # default aac"
    echo " -aac_decode libfdk_aac # For decoding xHE-AAC"
    echo " -latm 0|1"
    echo " -opus_br <kbit>     # 2ch br in kbit default 64"
    echo " -chan_sel <chan_id>=<str>[,<str>]"
    echo " -chan_set <chan_id>=<param>"
    echo " -title_set <title>=<param>"
}

help() {
    #echo [$1][$2]
    #echo [$decition]
    echo $(basename $0) parameter
    if [ "$decition" == "-v" ]
    then
	help_Video
	help_Configuration_V
	exit
    fi
    if [ "$decition" == "-a" ]
    then
	help_Audio
	help_Configuration_A
	exit
    fi
    echo " -h [-v|-a] # this"
    help_Input
    help_Output
    help_Video
    help_Audio
    help_Automation
    help_Configuration
    #echo "Other"
    exit
}

file_size() {
    #set -x
    local size
    
    case $os in
	"FreeBSD")
	    # -rw-r--r--  1 root  wheel  1139384 Jun 22  2013 index
	    #size=$(ls -l $1|cut -d ' ' -f 5)
	    size=$(ls -lL "$1")
	    size=$(echo $size | cut -d ' ' -f 5)
	    ;;
	*)
	    size=$(stat -L "$1" -c "%s")
	    ;;
    esac
    echo $size
    #exit
}

add_vf() {
    #set -x
    if [ "$vf" == "" ]
    then
	vf="-vf $1"
    else
	vf=$vf","$1
    fi
    #set +x
}

hwdownload() {
    [ "$deinterlace" == "yadif" ] && return
    #if [ "$hwaccel" == "cuvid" ]
    if [ "$hwaccel" != "" ]
    then
	[[ "$vf" == *hwdownload* ]] && return
	add_vf hwdownload
	#set -x
	new_vtyp=nv12
	#echo $vtyp
	[ "$vtyp" == "yuv420p10le" ] && new_vtyp=p010le
	add_vf format=$new_vtyp
	#set +x
	#add_vf format=nv12
	#add_vf format=yuv420p10le
	#add_vf format=p010le
	#add_vf format=yuv420p
	[ "$deinterlace" != "" ] && deinterlace="yadif"
	#hwaccel=
    fi
}

parameter() {
    local w2=$2
    [ "$w2" == "-" ] && w2=
    [ "${2:0:1}" == '"' ] && w2=${2:1} && w2=${w2:0: -1}
    case $1 in
	"-h")
	    TODO=$1
	    INPUT=none
	    decition=$2
	    #help
	    ;;
	"-i")
	    INPUT=$2
	    ;;
	"-ia")
	    if [[ "$2" == *" "* ]]
	    then
		INPUTA="$INPUTA -i \"$2\""
	    else
		INPUTA="$INPUTA -i $2"
	    fi
	    ;;
	"-ic")
	    INPUTC=$2
	    OPT="$OPT -map_chapters 1"
	    ;;
	"-dvd")
	    INPUT=dvd
	    dvd_path=$2
	    ;;
	"-dvdvideo")
	    dvdvideo=1
	    ;;
	"-BD")
	    INPUT=BD
	    dvd_path=$2
	    ;;
	"-tr")
	    track=$2
	    ;;
	"-chn")
	    IFS=':' read chn start1 <<< $2
	    INPUT=chn
	    ;;
	"-attach")
	    attach_file=$2
	    ;;
	"--streams")
	    TODO=$1
	    ;;
	"--inf")
	    TODO=$1
	    ;;
	"--stat")
	    TODO=$1
	    INPUT=none
	    #status
	    ;;
	"--astat")
	    TODO=$1
	    INPUT=none
	    #status
	    ;;
	"--diag")
	    TODO=$1
	    INPUT=none
	    ;;
	"-o")
	    OUTPUT=$2
	    ;;
	"-copy"|"-cp")
	    OUTPUT=$2
	    h264=copy
	    h264_HD=
	    mpeg2=copy
	    vc1=copy
	    ac3_stereo=
	    mp2=copy
	    dts=copy
	    pcm=copy
	    dold=1
	    ;;
	"-r")
	    OPT="$OPT -r $2"
	    #add_vf fps=$2
	    fpso=$2
	    ;;
	"-fps_mode")
	    OPT="$OPT -fps_mode $2"
	    ;;
	"-b")
	    OPT_V="$OPT_V -b:v:0 $2"
	    h264_br="-b:v:0 $2"
	    mp3_b="-b:a $2"
	    hevc_cq=0
	    ;;
	"-ab")
	    #set -x
	    str=${2%=*}
	    ab=${2#*=}
	    if [ "$str" != "$ab" ]
	    then
		ab_str=$str
	    fi
	    #ab=$2
	    mp3_b="-b:a $ab"
	    aac_stereo_br=$ab
	    opus_br=$ab
	    dts_br=$ab
	    #[ "${opus_br:${#opus_br}-1:1}" == "k" ] && opus_br=${opus_br:0:${#opus_br}-1}
	    [ "${opus_br: -1}" == "k" ] && opus_br=${opus_br:0:-1}
	    #exit
	    ;;
	"-vb")
	    OPT_V="$OPT_V -b:v:0 $2"
	    h264_br="-b:v:0 $2"
	    hevc_cq=0
	    mpeg4_b=$2
	    ;;
	"-m4_b")
	    mpeg4_b=$2
	    ;;
	"-t")
	    OPT_G="$OPT_G -t $2"
	    ;;
	"-to")
	    #OPT_G="$OPT_G -to $2"
	    OPT="$OPT -to $2"
	    ;;
	"-ss")
	    # When using -ss, -to only works as expected if -ss is used as an output option.
	    #OPT_G="$OPT_G -ss $2"
	    OPT="$OPT -ss $2"
	    ss=$2
	    ;;
	"-copytb")
	    OPT="$OPT -copytb $2"
	    ;;
	"-bsf")
	    OPT="$OPT -bsf:v:0 $2"
	    ;;
	"-bsfa")
	    OPT="$OPT -bsf:a $2"
	    ;;
	"-fflags")
	    OPT_G="$OPT_G -fflags $2"
	    ;;
	"-dts_delta_threshold")
	    OPT_G="$OPT_G -dts_delta_threshold $2"
	    ;;
	"-avoid_negative_ts")
	    OPT_G="$OPT_G -avoid_negative_ts $2"
	    ;;
	"-test")
	    OPT="$OPT $2"
	    ;;
	"-testg")
	    OPT_G="$OPT_G $2"
	    ;;
	"-testi")
	    OPT_I="$OPT_I $2"
	    ;;
	"-test2")
	    OPT="$OPT $2 $3"
	    #shift
	    ;;
	"-test3")
	    OPT="$OPT $2 $3 $4"
	    #shift
	    #shift
	    ;;
	"-test3g")
	    OPT_G="$OPT_G $2 $3 $4"
	    #shift
	    #shift
	    ;;
	"-vc1")
	    vc1=$2
	    ;;
	"-h264")
	    h264=$2
	    h264_HD=
	    ;;
	"-h264_HD")
	    h264_HD=$w2
	    ;;
	"-h264_br_g")
	    h264_br_g=$2
	    ;;
	"-h264_br")
	    h264_br="-b:v:0 $2"
	    ;;
	"-hevc")
	    hevc=$2
	    ;;
	"-hevc_vaapi_preset")
	    hevc_vaapi_preset="$w2"
	    ;;
	"-hevc_qsv_preset")
	    hevc_qsv_preset="$w2"
	    ;;
	"-x265_preset")
	    x265_preset="$w2"
	    ;;
	"-libx265_preset")
	    libx265_preset="$w2"
	    ;;
	"-mpeg2")
	    mpeg2=$2
	    ;;
	"-mpeg4")
	    mpeg4=$2
	    ;;
	"-vp8")
	    vp8=$2
	    ;;
	"-vp9")
	    vp9=$2
	    ;;
	"-av1")
	    av1=$2
	    ;;
	"-vcodec"|"-vc")
	    vcodec=$2
	    ;;
	"-deint")
	    deinterlace=$w2
	    ;;
	"-deint_mode")
	    deint_mode=$w2
	    ;;
	"-acodec"|"-ac")
	    #set -x
	    str=${2%=*}
	    ac=${2#*=}
	    if [ "$str" != "$ac" ]
	    then
		acodeca[$str]=$ac
	    else
		acodec=$2
	    fi
	    #exit
	    ;;
	"-dts")
	    dts=$2
	    ;;
	"-ac3")
	    ac3=$2
	    ;;
	"-ac3v")
	    ac3v=$2
	    ;;
	"-dnorm")
	    dnorm=$2
	    ;;
	"-ac3_stereo")
	    ac3_stereo=$w2
	    ;;
	"-ac3_stereo_level")
	    ac3_stereo_level=$2
	    ;;
	"-eac3")
	    eac3=$2
	    ;;
	"-aac_6")
	    aac_6=$2
	    ;;
	"-aac")
	    aac=$2
	    ;;
	"-aac_stereo_br"|"-aac_br")
	    aac_stereo_br=$2
	    ;;
	"-aac_6ch_br")
	    aac_6ch_br=$2
	    ;;
	"-aac_vbr")
	    aac_vbr=$2
	    ;;
	"-latm")
	    latm=$2
	    [ "$latm" == "1" ] && OPT="$OPT -latm 1 -mpegts_flags latm -flags:a +global_header"
	    ;;
	"-aac_decode")	# libfdk_aac, for decoding xHE-AAC
	    aac_decode=$2
	    ;;
	"-opus")
	    opus=$2
	    ;;
	"-opus_br")
	    #set -x
	    opus_br=$2
	    #[ "${opus_br:${#opus_br}-1:1}" == "k" ] && opus_br=${opus_br:0:${#opus_br}-1}
	    [ "${opus_br: -1}" == "k" ] && opus_br=${opus_br:0:-1}
	    #exit
	    ;;
	"-mp2")
	    mp2=$2
	    ;;
	"-mp2_128")
	    mp2_128=$2
	    ;;
	"-mp3")
	    mp3=$2
	    ;;
	"-pcm")
	    pcm=$2
	    ;;
	"--upmix")
	    upmix=1
	    ;;
	"-upmix")
	    upmix=1
	    win_func=$2
	    ;;
	"-h264_q"|"-crf")
	    crf=$2
	    ;;
	"-quality")
	    quality="-quality $2"
	    ;;
	"-hevc_q"|"-cq")
	    hevc_cq=$2
	    ;;
	"-b_ref_mode")
	    b_ref_mode="-b_ref_mode $2"
	    ;;
	"-vp9_q"|"-gq")
	    gq=$2	# VP8
	    ;;
	"-qv"|"-vq"|"-qp")
	    #OPT="$OPT -q:v $2"
	    qv=$2
	    crf=$2
	    hevc_cq=$2
	    gq=$2	# VP9
	    qav1=$2
	    ;;
	"-av1_q"|"-qav1")
	    qav1=$2
	    ;;
	"-av1_preset")
	    av1preset=$2
	    ;;
	"-g")
	    gop_vdr_w="$2"
	    gop_vdr="-g $2"
	    gop_file=$gop_vdr
	    ;;
	"-vf")
	    add_vf $2
	    ;;
	"-filter_complex")
	    OPT="$OPT $2"
	    ;;
	"-overlay")
	    #echo $INPUT
	    in=$INPUT
	    #[ "$in" == "vdr" ] && in=00001.ts
	    hwdownload
	    add_vf "subtitles=\"$in\":si=$2"
	    #add_vf "subtitles=$in:si=$2"
	    #OPT_G="$OPT_G -canvas_size:$stro "$hw"x"$vw
	    #OPT_G2="$OPT_G2 -canvas_size 1920x1080"
	    #OPT="$OPT -sn"
	    #exit
	    ;;
	"--8bit")
	    s8bit=1
	    ;;
	"-maxr")
	    OPT="$OPT -maxrate $2 -bufsize 1835k"
	    ;;
	"-crop")
	    #crop="-vf crop=$2"
	    #hwdownload
	    #[ "$hwaccel" == "cuvid" ] && add_vf hwdownload && add_vf format=nv12
	    #add_vf "crop=$2"
	    crop="crop=$2"
	    ;;
	"-croph")
	    crop="crop=h=in_h-$2:y=$2"
	    ;;
	"--LB")
	    #hwdownload
	    #[ "$hwaccel" == "cuvid" ] && add_vf hwdownload && add_vf format=nv12
	    #add_vf "crop=iw:ih/4*3"
	    crop="crop=iw:ih/4*3"
	    aspect="-aspect 16:9"
	    #parameter "--nohw"
	    ;;
	"-zoom")
	    #hwdownload
	    #[ "$hwaccel" == "cuvid" ] && add_vf hwdownload && add_vf format=nv12
	    #add_vf "crop=iw/$2:ih/$2"
	    crop="crop=iw/$2:ih/$2"
	    ;;
	"-scale")
	    scale=$2
	    case "$scale" in
		"hd720")
		    scale="1280:720"
		    ;;
		"hd1080")
		    scale="1920:1080"
		    ;;
		"qhd")
		    scale="960:540"
		    ;;
		"pal")
		    scale="720:576"
		    ;;
	    esac
	    ;;
	"-aspect")
	    aspect="-aspect $2"
	    ;;
	"-va")
	    video_add=$2
	    ;;
	"-af")
	    OPT="$OPT -af $2"
	    ;;
	"-ar")
	    OPT="$OPT -ar $2"
	    ;;
	"-dsur")
	    #OPT="$OPT -dsur_mode $2"
	    str=${2%=*}
	    dsur=${2#*=}
	    if [ "$str" == "$dsur" ]
	    then
		OPT="$OPT -dsur_mode $dsur"
	    else
		#OPT="$OPT -dsur_mode:$str $dsur"
		dsura[$str]=$dsur
	    fi
	    ;;
	"--dpl")
	    acodec=eac3
	    OPT="$OPT -dsur_mode 2"
	    #OPT="$OPT -dsur_mode 2 -metadata:s:a encoder=eac3_Dolby_Surround"
	    dpl=99
	    ;;
	"-dpl")
	    acodeca[$2]=eac3
	    #OPT="$OPT -dsur_mode:$2 2"
	    dpl=$2
	    ;;
	"-ch")
	    achannels=$2
	    #[ "$2" == "2" ] && OPT="$OPT -af pan=stereo|c0=FL|c1=FR"
	    #[ "$2" == "2" ] && OPT="$OPT -filter:a pan=stereo|c0=FL|c1=FR"
	    #[ "$2" == "2" ] && OPT="$OPT -ac 2"
	    #[ "$2" != "2" ] && echo "only '-ch 2' implemented" && exit 8
	    case $2 in
		"2")
		    OPT="$OPT -ac 2"
		    ;;
		"dplii")
		    # seems to be the same as -ac 2 only
		    OPT="$OPT -af aresample=matrix_encoding=dplii:lfe_mix_level=2 -ac 2"
		    ;;
		*)
		    echo "-ch $2, only '-ch 2|dplii' implemented"
		    exit 8
		    ;;
	    esac
	    ;;
	"-vol")
	    #set -x
	    str=${2%=*}
	    vol=${2#*=}
	    if [ "$str" == "$vol" ]
	    then
		OPT="$OPT -filter:a volume=$vol"
	    else
		#OPT="$OPT -filter:$str volume=$vol"
		volumea[$str]=$vol
	    fi
	    #exit
	    ;;
	"-h264enc")
	    h264enc=$2
	    ;;
	"-h264_level")
	    h264_level=$2
	    ;;
	"-h264_profile")
	    h264_profile=$2
	    ;;
	"-x264_preset")
	    x264_preset=$2
	    ;;
	"-hevcenc")
	    hevcenc=$2
	    ;;
	"-hevc_level")
	    hevc_level=$2
	    level_hevc="-level $2"
	    ;;
	"-hevc_profile")
	    hevc_profile=$2
	    ;;
	"-profile")
	    profile=$2
	    ;;
	"-preset")
	    preset=$2
	    ;;
	"-tier")
	    tier=$2
	    ;;
	"-hevc_preset")
	    hevc_preset=$2
	    ;;
	"-nvenc_preset")
	    nvenc_preset=$2
	    ;;
	"-nvenc_rc")
	    nvenc_rc=$2
	    ;;
	"-pix_fmt")
	    OPT="$OPT -pix_fmt $2"
	    ;;
	"-vp9enc")
	    vp9enc=$2
	    ;;
	"-av1enc")
	    av1enc=$2
	    ;;
	"-aaclib")
	    aaclib=$2
	    ;;
	"-hwaccel")
	    hwaccel=$w2
	    case "$2" in
		"cuvid"|"cuda")
		    h264enc=h264_nvenc
		    hevcenc=hevc_nvenc
		    ;;
		"vaapi")
		    h264enc=h264_vaapi
		    hevcenc=hevc_vaapi
		    vp9enc=vp9_vaapi
		    av1enc=av1_vaapi
		    ;;
		"qsv")
		    h264enc=h264_qsv
		    hevcenc=hevc_qsv
		    vp9enc=vp9_qsv
		    av1enc=av1_qsv
		    ;;
		"qsvh")
		    h264enc=h264_qsv
		    hevcenc=hevc_qsv
		    vp9enc=vp9_qsv
		    av1enc=av1_qsv
		    ;;
		"vdpau"|"-"|"vulkan"|"drm"|"opencl"|"none")
		    ;;
		*)
		    echo "-hwaccel" $2 "wrong"
		    exit 8
		    ;;
	    esac
	    ;;
	"-libva")
	    libva=$2
	    ;;
	"-gpu")
	    gpu=$2
	    ;;
	"--nohw")
	    #deinterlace="-filter:v yadif"
	    deinterlace="yadif"
	    hwaccel=
	    #OPT_G=
	    ;;
	"-vdr")
	    VDRDIR=$2
	    ;;
	"-sel")
	    #set -x
	    select_str0=0
	    if [[ "$2" == *:* ]]
	    then
		select_str0=${2%:*}
		select_str=${2#*:}
	    else
		select_str=$2
	    fi
	    #exit
	    ;;
	"-sell")
	    sell=$2
	    ;;
	"--selb")
	    select_str0=0
	    sel_best=1
	    ;;
	"--sel_eac3")
	    select_str0=0
	    sel_best="eac3"
	    ;;
	"-chan_sel")
	    #set -x
	    chan_sel_id[$chan_sel_i]=${2%=*}
	    chan_sel[$chan_sel_i]=${2#*=}
	    chan_sel_i=$(($chan_sel_i+1))
	    #exit
	    ;;
	"-chan_set")
	    #set -x
	    chan_set_id[$chan_set_i]=${2%=*}
	    chan_set[$chan_set_i]="${2#*=}"
	    chan_set_i=$(($chan_set_i+1))
	    #exit
	    ;;
	"-title_set")
	    #set -x
	    title_set_id[$title_set_i]=${2%=*}
	    title_set[$title_set_i]="${2#*=}"
	    title_set_i=$(($title_set_i+1))
	    #exit
	    ;;
	"--info")
	    info=1
	    ;;
	"-lang")
	    set_lang $2
	    ;;
	"-probesize")
	    OPT_G="$OPT_G -probesize $2"
	    ;;
	"-anal"|"-analyzeduration")
	    OPT_G="$OPT_G -analyzeduration $2"
	    ;;
	"--q")
	    quiet=1
	    ;;
	"--nochapt")
	    nochapt=1
	    ;;
	"-marks_mkv")
	    marks_mkv=$2
	    ;;
	"-chapt_marks")
	    chapt_marks=$2
	    [ "$2" == "logfile" ] && TODO=$1
	    ;;
	"-DP")
	    OPT="$OPT -dsur_mode $2"	# 2 on
	    ;;
	"-stro")
	    set_streamo $2
	    ;;
	"-disp")
	    set_disposition $2
	    ;;
	"-def")
	    default=$2
	    ;;
	"-skip")
	    skip=$2
	    ;;
	"--dold")
	    dold=1
	    ;;
	"-mjpeg")
	    mjpeg=$2
	    ;;
	"-meta_rem")
	    OPT="$OPT -metadata $2=\"\""
	    ;;
	"--as")
	    TODO=$1
	    INPUT=none
	    #server
	    ;;
	"--asd")
	    TODO=$1
	    INPUT=none
	    #server
	    ;;
	"--ak")
	    TODO=$1
	    INPUT=none
	    #server_kill
	    ;;
	"-server_pid")
	    echo "deprecated, use -pid_dir"
	    eval runs=$2
	    eval runvt=$(dirname $2)/vt.pid
	    ;;
	"-pid_dir")
	    eval runs=$2/vt_server.pid
	    eval runvt=$2/vt.pid
	    ;;
	"-server_log")
	    eval logs=$2
	    ;;
	"--conf")
	    TODO=$1
	    INPUT=none
	    #pa=$@
	    #auto_conf
	    ;;
	"--confr")
	    TODO=$1
	    INPUT=none
	    ;;
	"-confr")
	    TODO=$1
	    INPUT=none
	    min_br=$2
	    ;;
	"-min_br")
	    min_br=$2
	    ;;
	"-confsz")
	    TODO=$1
	    INPUT=none
	    min_size=$2
	    ;;
	"--a_conf")
	    #auto_sh_conf
	    TODO=$1
	    INPUT=none
	    ;;
	"--alog")
	    cat $logs
	    exit
	    ;;
	"--aq")
	    TODO=$1
	    INPUT=none
	    ;;
	"--ac")
	    TODO=$1
	    INPUT=none
	    ;;
	"--ac_del")
	    TODO=$1
	    INPUT=none
	    ;;
	"--aplay")
	    TODO=$1
	    INPUT=none
	    ;;
	"--rmdel"|"--lsdel")
	    TODO=$1
	    INPUT=none
	    ;;
	"--lsdel_s")
	    TODO=$1
	    INPUT=none
	    ;;
	"--ardy")
	    TODO=$1
	    INPUT=none
	    ;;
	"--auto")
	    auto=1
	    dialog=0
	    #quiet=1
	    ;;
	"--out_stat")
	    out_stat="stat"
	    ;;
	"-out_stat")
	    out_stat=$w2
	    ;;
	"-dialog")
	    dialog=$2
	    tset=1
	    ;;
	"--apc")
	    apply_codec=1
	    ;;
	"-ffmpeg")
	    ffmpeg="$2"
	    ;;
	"-ffprobe")
	    ffprobe="$2"
	    ;;
	"-ffpath")
	    ffmpeg="$2"/ffmpeg
	    ffprobe="$2"/ffprobe
	    if [ -e "$2"/.libpath ]
	    then
		libpath=$(<"$2"/.libpath)
		[ ${libpath:0:1} != '/' ] && libpath="$2/$libpath"
		export LD_LIBRARY_PATH=$libpath
	    fi
	    ;;
	"-odir")
	    odir=$2
	    ;;
	"-mark")
	    marker=$2
	    ;;
	"-threads")
	    threads=$2
	    OPT="$OPT -threads $2"
	    ;;
	"--p"|"--c")
	    check=1
	    ;;
	"--sim")
	    sim=1
	    ;;
	"--trace")
	    exec > trace.log 2>&1
	    set -x
	    trace=1
	    out_stat=
	    ;;
	"-trace")
	    exec > $2 2>&1
	    set -x
	    ;;
	"--trace2")
	    exec 2> trace.log
	    set -x
	    ;;
	"--v")
	    OPT_G="$OPT_G -v verbose"
	    ;;
	"-postproc")
	    postproc=$2
	    ;;
	"-delogo")
	    #set -x
	    IFS=: read x y w h show <<< $2
	    #p="\"[0:v]delogo=x=$x:y=$y:w=$w:h=$h"
	    #[ "$show" != "" ] && p=$p":show=$show"
	    #p=$p"[v]\""
	    p="delogo=$2"
	    add_vf $p
	    #OPT="$OPT -filter_complex $p"
	    #exit
	    ;;
	"--rts")
	    TODO=$1
	    INPUT=none
	    ;;
	"--rtse")
	    TODO=$1
	    INPUT=none
	    ;;
	"--rtsk")
	    TODO=$1
	    INPUT=none
	    ;;
	"-rtc")
	    rt_client=1
	    rt_server=$2
	    ;;
	"--2pass")
	    pass="-pass 2"
	    ;;
	"--chk_error")
	    TODO=$1
	    ;;
	"-chk_error")
	    chk_error=$2
	    ;;
	*)
	    echo $1 wrong
	    [ "$2" == "" -a "${1:1:1}" != "-" ] && echo "try -"$1
	    exit 8
	    ;;
    esac
}

read_configuration() {
    #set -x
    if [ -e $1 ]
    then
	while read line
	do
	    #echo $line
	    [ "${line:0:1}" == "#" ] && continue
	    [ "$line" == "" ] && continue
	    #line=$(echo $line|cut -d '#' -f 1)
	    IFS=# read line _ <<< $line
	    read p1 p2 <<< $line
	    parameter $p1 "$p2"
	    #parameter $line
	done < $1
    fi
    #set +x
    #exit
}


set_lang() {
    #set -x
    IFS=,
    for la in $1
    do
	l=${la#*=}
	str=${la%=*}
	if [[ "$str" == *-* ]]
	then
	    s1=${str%-*}
	    s2=${str#*-}
	    for (( i=$s1 ; i<=$s2 ; i++ ))
	    do
		lang[$i]=$l
	    done
	else
	    lang[$str]=$l
	fi
    done
    unset IFS
    #exit
}

declare -a streamo

set_streamo() {
    #set -x
    IFS=,
    for s in $1
    do
	str=${s%=*}
	to=${s#*=}
	streamo[$str]=$to
	[ $to -eq 1 ] && disp="$disp -disposition:1 default"
	[ $to -gt 1 ] && disp="$disp -disposition:$to 0"
    done
    unset IFS
    #exit
}

set_disposition() {
    #set -x
    local str
    local disp
    IFS_save=$IFS
    IFS=,
    for s in $1
    do
	str=${s%=*}
	disp=${s#*=}
	#OPT="$OPT -disposition:$str $disp"
	dispa[$str]=$disp
    done
    #unset IFS
    IFS=$IFS_save
    #exit
}

parameter_line() {
    #declare -a $parametera_log
    while [ "$1" ]
    do
	#parameter "$1" "$2" "$3" "$4"
	parameter "$@"
	if [ "${1:0:1}" == "-" -a "${1:1:1}" != "-" ]
	then
	    parameter_log="$parameter_log $1 $2\n"
	    parameter_auto="$parameter_auto $1 $2|"
	    shift
	else
	    parameter_log="$parameter_log $1\n"
	    parameter_auto="$parameter_auto $1|"
	fi
	shift
    done
}

select_from_to() {
    #set -x
    IFS=,
    del=
    for s in $select_str
    do
	#echo $s
	if [[ "$s" == *-* ]]
	then
	    s1=${s%-*}
	    s2=${s#*-}
	    for (( i=$s1 ; i<=$s2 ; i++ ))
	    do
		#echo $i
		select_str2=$select_str2$del$i
		del=,
	    done
	else
	    select_str2=$select_str2$del$s
	fi
	del=,
    done
    unset IFS
    #IFS=
    #exit
}

#set -x
[ "$conf" != "" ] && read_configuration $conf
[ "$conf1" != "" ] && read_configuration $conf1
parameter_line "$@"

#[ "$auto" == "1" ] && read_configuration $vtc
[ -e $vtc ] && read_configuration $vtc
#exit

select_from_to

status() {
    # vdr3-2 /usr/local/vdr/vdr-2.4.1 # to_h264_sh_current -s
    # /disk2/video/Blindspot/%In_der_Falle/2019-12-19.01.40.108-0.rec
    # Duration: 00:40:27.48,
    # fps=430 time=00:20:31.36 50% Comp=273%  8.6x
    # Size: 2575433 -> 940032
    # Est: 00:02:19

    #set -x
    local log
    local info
    local nw
    local l
    local fps
    local fps1
    local t=$t_stat
    #echo "IFS="$IFS
    #log=$(cat $vtlog)
    #log="$1"
    log="$@"
    CEOL=""
    [ "$dialog" == "0" ] && CEOL="\033[K"
    [ ! -e "$log" ] && exit 8
    [ "$dialog" == "0" -a "$noff" == "" ] && echo -en '\033[;H'
    logo=$log
    [ "$dialog" != "0" ] && logo=${log:0:55}
    echo $logo > $t
    olddir=$(grep "PWD:" "$log")
    olddir=${olddir:5}
    info="$olddir/info"
    if [ -e "$info" ]
    then
	sender=$(grep ^C "$info"|cut -d \  -f 3-)
	#echo $sender
    fi
    oldsize=$(grep "oldsize=" "$log")
    oldsize=${oldsize#*=}
    # Duration: 01:51:21.66, start: 16209.384800, bitrate: 3498 kb/s
    dur1=$(grep "Duration:" "$log"|head -n 2)
    #echo $dur
    #dur=$(echo $dur1|cut -d \  -f 2)
    read _ dur _ _ _ bitr1 _ <<< $dur1
    dur=${dur:0:8}
    if [ "${dur:0:3}" == "N/A" ]
    then
	#echo $dur1 | tail -n 1
	dur=${dur1##*Duration: }
	dur=${dur:0:8}
    fi
    durs=1
    [ "${dur:0:3}" != "N/A" ] && durs=$($date -u "+%s" -d "1970-01-01 $dur")
    durs1ms=$durs${dur:9:2}
    #fps1=$(grep "Video:" $log|head -n 1)
    fps1=$(grep "Video:" "$log"|tail -n 1)
    # Stream #0:0(eng): Video: h264 (High), yuv420p(tv, bt709, top first), 1920x1080 [SAR 1:1 DAR 16:9], 25 fps, 25 tbr, 1k tbn, 50 tbc Stream #0:0(eng): Video: hevc (hevc_nvenc) (Main), cuda, 1920x1080 [SAR 1:1 DAR 16:9], q=-1--1, 2000 kb/s, 50 fps, 1k tbn, 50 tbc
    # Stream #0:0[0x1ff]: Video: hevc (Main) (HEVC / 0x43564548), yuv420p(tv), 1920x1080 [SAR 1:1 DAR 16:9], 25 fps, 25 tbr, 90k tbn
    #set -x
    fps1=${fps1%fps,*}
    nw=$(echo $fps1|wc -w)
    fps1=$(echo $fps1|cut -d \  -f $nw)
    #echo fps1=$fps1
    echo "Duration: $dur, fps=$fps1 $sender" >> $t
    # frame=15001 fps=11331 q=-1.0 Lsize=  173773kB time=00:04:59.98 bitrate=4745.4kbits/s speed= 227x
    # frame= 1739 fps=1739 q=34.0 size=    2560KiB time=00:00:44.92 bitrate= 466.9kbit
    # frame= 1521 fps=253 q=29.0 size=   10496KiB time=N/A bitrate=N/A speed=N/A
    # size=   28160kB time=00:01:22.70 bitrate=2789.4kbits/s speed=81.7x
    # size=   43264kB time=00:02:04.00 bitrate=2858.2kbits/s speed=  82x
    #l=$(grep "^frame=" $(cat $vtlog) | tr '\r' '\n'| tail -n 1)
    # t=$(tr '\r' '\n' < $l | grep -a "^frame=" | tail -n 1)
    #l=$(grep "^frame=" $log | tr '\r' '\n'| tail -n 1)
    l=$(tr '\r' '\n' < "$log" | grep -a "^frame=" | tail -n 1)
    [ "$l" == "" ] && l=$(tr '\r' '\n' < "$log" | grep -a "^size=" | tail -n 1)
    #echo $l
    frame1=${l#*frame=}
    read frame _ <<< $frame1
    dur2=${l#*time=}
    dur2=${dur2:0:8}
    dur2s=1
    #if [ "$dur2" != "N/A,’" ]
    #set -x
    if [ "$dur2" != "N/A bitr" ]
    then
	dur2s=$($date -u "+%s" -d "1970-01-01 $dur2")
	if [ $dur2s -eq $dur2sa -a 0 -eq 1 ]
	then
	    #set -x
	    #dur2s=$(($frame/$fps1))
	    dur2s=$(bc <<< "$frame/$fps1")
	    dur2=$($date "+%T" -u -d @$dur2s)
	    #exit
	else
	    dur2sa=$dur2s
	fi
	[ "$dur2sa" == "" ] && dur2sa=$dur2s
    else
	#dur2s=$(($frame/$fps1))
	dur2s=$(bc <<< "$frame/$fps1")
	dur2=$($date "+%T" -u -d @$dur2s)
    fi
    #[ "$frame" != "" ] && dur2s=$(bc <<< "$frame/$fps1") && dur2=$($date "+%T" -u -d @$dur2s)
    #echo $frame $dur2 $($date "+%T" -u -d @$(bc <<< "$frame/$fps1"))" " >> $t
    #exit
    fps=${l#*fps=}
    if [ "$fps" != "$l" ]
    then
	fps=$(echo $fps|cut -d \  -f 1)
    else
	fps=1
    fi
    size=${l#*size=}
    [ "$size" == "" ] && return
    size=$(echo $size|cut -d \  -f 1)
    e=${size: -2}
    [ "$e" == "kB" ] && size=${size:0:-2}
    [ "$e" == "iB" ] && size=${size:0:-3}
    speed=${l#*speed=}
    read speed _ <<< $speed
    time=${l##*time=}
    time=$(echo $time | cut -d \  -f 1)
    #[ "$time" == "N/A" ] && return
    if [ "$time" == "N/A" ]
    then
	#time2=$(($frame/$fps1))
	time2=$(bc <<< "$frame/$fps1")
    else
	time2=$($date +"%s" -u -d "1970-01-01 ${time:0:8}")
    fi
    bitr2=${l##*bitrate=}
    bitr2=$(echo $bitr2 | cut -d \  -f 1)
    restz=$(($durs-$time2))
    if [ "$dur2" != "N/A,’" ]
    then
	prz=$(($dur2s*100/$durs))
	prm=$(($dur2s*1000/$durs))
    fi
    unset drop
    if [[ "$l" == *"drop="* ]]
    then
	drop=${l##*drop=}
	drop="drop="$(echo $drop | cut -d \  -f 1)
    fi
    #echo "fps=$fps, size=$size, time=$dur2, speed=$speed"
    #printf "fps=%3d, size=%d, time=%s, speed=%s\n" $fps $size $dur2 $speed
    if [ $prm -gt 0 ]
    then
	#set -x
	size2=$(($size*1000/$prm))
	#if [[ "$fps1" == *.* ]]
	[ "$fps" == "0.0" ] && return
	[[ "$fps1" == *.* ]] && p1=1
	if [ "$fps" == "1" ]
	then
	    sp=$(echo $speed)
	    #fps=$(($fps1*${sp:0: -1}))
	    fps=$(echo "$fps1*${sp:0: -1}"|bc)
	fi
	[[ "$fps" == *.* ]] && p2=1
	if [ "$p1" == "1" -o "$p2" == 1 ]
	then
	    exptime=$(echo "$restz*$fps1/$fps"|bc)
	else
	    exptime=$(($restz*$fps1/$fps))
	fi
	#echo $prz"% exp. size="$size2" exp. time="$(date "+%T"  -u -d @$exptime)
	exp=$($date "+%T" -u -d @$exptime)
	przs=$(($size2*100/$oldsize))
	#printf "%3d%% exp.size=%d exp.time=%s compr=%d%%\n" $prz $size2 $exp $przs
	echo -e "fps=$fps time=$dur2 $prz% $speed $drop$CEOL" >> $t
	[ $bitrate -gt 0 ] && echo -e "$bitr1 -> $bitr2$CEOL" >> $t
	#echo "Size: $oldsize -> $size2 $przs%"
	echo -e "Size: $(show_size $oldsize) -> $(show_size $size2) $przs%$CEOL" >> $t
	[ $restz -gt 0 ] && echo -e "Est: $exp$CEOL" >> $t
	#[ -e $olddir/vt.lck ] && echo "Est: $exp"
	#date -u -d @$exptime
	#echo
	#df -h --output=avail "$log"
	#df -h $log
	#cat $t | dialog --begin 0 0 --progressbox 15 -1
	if [ "$dialog" == "0" ]
	then
	    #echo -en '\033[;H'
	    cat $t
	    rm $t
	fi
    fi
    #exit
}

ctrl_c_a() {
    #echo "ctrl_c_a $PID2"
    tset
    kill -15 $PID2
    echo "cancelled"
    exit
}

run_stat() {
    local t=$t_stat
    [ "$PID2" != "" -a -e /proc/$PID2 ] && kill -15 $PID2
    #while true; do sleep 2s; clear; status "$log_c"; echo -e "\ns=stat, l=log"; done &
    #while true; do sleep 2s; clear; status "$log_c"; echo -e "\n$msg"; done &
    #clear
    printf "\033c"
    while true
    do 
	#clear
	prz=0
	status "$1"
	echo >> $t
	if [ "$os" == "Linux" ]
	then
	    echo -en "$CEOL"
	    #df -h --output=avail "$1" >> $t
	    avail=$(df --output=avail "$1"|tail -n 1)
	    echo "Avail: $(show_size $avail) need: $(show_size $(($size2-$size))) " >> $t
	else
	    #gdf -h --output=avail "$1" >> $t
	    avail=$(gdf --output=avail "$1"|tail -n 1)
	    echo "Avail: $(show_size $avail) need: $(show_size $(($size2-$size))) " >> $t
	fi
	#echo -e "\n$msg" >> $t
	#cat $t | dialog --keep-window --begin 0 0 --no-shadow --progressbox 15 -1; \
	#dialog --keep-window --begin 0 0 --no-shadow --textbox $t 15 -1
	#dialog --keep-window --begin 0 0 --no-shadow --tailboxbg $t 15 -1; \
	ts=$(<$t)
	#dialog --keep-window --begin 0 0 --no-shadow --infobox "$ts" 15 -1; \
	if [ "$dialog" != "0" ]
	then
	    #echo $prz | dialog --begin 4 10 --keep-window --no-shadow \
	    #--hline "$msg" --infobox "$ts" 11 60 \
	    #--and-widget --begin 15 10 --keep-window --no-shadow --gauge "" 5 60 0
	    dialog --begin 4 10 --keep-window --no-shadow \
	    --hline "$msg" --mixedgauge "$ts" 16 60 $prz
	else
	    #echo -en '\033[;H'
	    cat $t
	    echo -e "\n$msg"
	fi
	sleep 2
    done &
    PID2=$!
}

run_log() {
    [ "$PID2" != "" -a -e /proc/$PID2 ] && kill -15 $PID2
    if [ "$dialog" != "0" ]
    then
	log_d $1
    else
	echo $1
	tail -f "$1" &
	PID2=$!
    fi
}

log_d() {
    local h
    local w
    local log="$1"
    #set -x
    local s=$(dialog --stdout --print-maxsize) # MaxSize: 24, 80
    read _ h w <<< $s
    h=${h//,/}
    #tail -f $log | dialog --backtitle $log --no-shadow --progressbox 20 -1
    #tail -f $log | dialog --no-shadow --hline "$msg" --progressbox $log $(($h-2)) -1 &
    #tail -f $log | dialog --no-shadow --progressbox $log -1 -1 &
    tail -f $log | dialog --no-shadow --hline "$msg" --progressbox $log -1 -1 &
    PID2=$!
}

astat_key() {
	PID1=$(<$runvtf)
	key=$1
	case $key in
	    l)
		run_log "$log"
		lastkey=$key
		;;
	    d)
		#[ -e /proc/$PID2 ] && kill -15 $PID2
		#log_d "$log"
		if [ "$dialog" != "0" ]
		then
		    dialog=0
		else
		    dialog=1
		    tset=1
		fi
		[ -e /proc/$PID2 ] && kill -15 $PID2
		run_stat "$log"
		;;
	    h)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		echo "s status, b +bitrate" > $t_stat
		echo "l logfile" >> $t_stat
		echo "w switch logfile <-> status" >> $t_stat
		echo "c --ac" >> $t_stat
		echo "d switch dialog <-> text" >> $t_stat
		echo "q quiet" >> $t_stat
		echo "t halt" >> $t_stat
		echo "x exit" >> $t_stat
		echo "h this page" >> $t_stat
		if [ "$dialog" != "0" ]
		then
		    dialog --begin 4 10 --keep-window --no-shadow \
			--hline "Help" --infobox "$(<$t_stat)" 11 60
		else
		    echo
		    cat $t_stat
		fi
		;;
	    s)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		run_stat "$log"
		lastkey=$key
		;;
	    w)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		if [ $lastkey == "s" ]
		then
		    run_log "$log"
		    lastkey=l
		else
		    run_stat "$log"
		    lastkey=s
		fi
		;;
	    b)
		if [ $bitrate -eq 0 ]
		then
		    bitrate=1
		else
		    bitrate=0
		fi
		[ -e /proc/$PID2 ] && kill -15 $PID2
		run_stat "$log"
		;;
	    f)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		less -S "$log"
		run_stat "$log"
		;;
	    m)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		mcview "$log"
		run_stat "$log"
		;;
	    c)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		#dialog=0
		#noff=1
		f=$t_stat"-2"
		#auto_check > $f
		vdr-transcode --ac > $f
		if [ "$dialog" != "0" ]
		then
		    dialog --textbox "$f" -1 -1
		else
		    less "$f"
		fi
		#dialog=1
		run_stat "$log"
		;;
	    q)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		#clear
		printf "\033c"
		echo -e $msg
		;;
	    t)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		;;
	    x)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		exit
		;;
	    p)
		kill -STOP $PID1
		kill -15 $PID2
		echo " resume with r"
		;;
	    r)
		kill -CONT $PID1
		[ -e /proc/$PID2 ] && kill -15 $PID2
		run_stat "$log"
		;;
	    +)
		renice --relative +5 -p $PID1
		;;
	    -)
		renice --relative -5 -p $PID1
		;;
	    k)
		[ -e /proc/$PID2 ] && kill -15 $PID2
		echo "Abbruch? n/j"
		lastkey=k
		;;
	    n)
		lastkey=
		run_log "$log"
		;;
	    j)
		if [ "$lastkey" == "k" ]
		then
		    kill -15 $PID1
		    run_log "$log"
		fi
		;;
	esac
	#lastkey=$key
}

astat() {
    #set -x
    #echo $vtlog
    [ -e $vtlog ] && log=$(<$vtlog)
    [ ! -e "$vtlog" ] && exit 8
    [ ! -e "$log" ] && exit
    #exit
    trap ctrl_c_a SIGINT
    #msg="s=\033[1ms\033[0mtat, l=\033[1ml\033[0mog, q=\033[1mq\033[0muiet, h=\033[1mh\033[0malt, x=e\033[1mx\033[0mit"
    #msg="s=stat, l=log, q=quiet, h=halt, x=exit"
    msg="s=stat, l=log, h=help, x=exit"
    #msg="s=stat, l=log, h=help, x=e\033[1mx\033[0mit"
    run_stat "$log"
    lastkey=s
    while true
    do
	log=$(<$vtlog)
	if [ "$log" != "$loga" ]
	then
	    [ -e /proc/$PID2 ] && kill -15 $PID2
	    #run_stat "$log"
	    sleep 2
	    #clear
	    printf "\033c"
	    astat_key $lastkey
	fi
	read -t 2 -n 1 key
	[ "$key" != "" ] && astat_key $key
	loga=$log
    done
    [ "$tset" != "" ] && tset
    exit
}

diag() {
    #set -x
    #v=$($ffmpeg -version)
    #v=$(echo $v | cut -d \  -f 3)
    read _ _ v _ <<< $($ffmpeg -version)
    #echo $v
    #exit
    vtp=$(which vdr-transcode)
    d=$($date "+%F" -r $vtp)
    echo "vdr-transcode $d ffmpeg Version $v"
    #set -x
    os=$(grep -h PRETTY_NAME /etc/*-release)
    #os=$(echo $os | cut -d ':' -f 2)
    eval $os
    echo $PRETTY_NAME
    #os=$(echo $os | cut -d '=' -f 2)
    #echo $os
    #exit
    #uname -p
    proc=$(uname -p)
    [ "$proc" == "unknown" ] && proc=$(lscpu | grep "Model name:")
    # grep -m 1 "model name" /proc/cpuinfo
    echo $proc
    echo
    if [ -e $conf ]
    then
	echo "===================================="
	echo $conf
	#cat $1 >> $log_c
	while read line
	do
	    [ "${line:0:1}" != "#" ] && echo $line
	done < $conf
	echo "===================================="
	echo
    fi
    which mediainfo 2> /dev/null
    if [ $? -ne 0 ]
    then
	echo "mediainfo missing"
    fi
    echo
    $ffmpeg -hide_banner -hwaccels
    lspci | grep VGA
    if [ -e /proc/asound/NVidia ]
    then
	#lspci -nnk | grep -A3 "\[03..\]:"
	xlog=/var/log/Xorg.0.log
	[ -e $xlog ] && grep "NVIDIA GPU " $xlog
	nvidia-smi | grep NVIDIA-SMI
	echo
	$ffmpeg -hide_banner -encoders | grep nvenc
	echo
	$ffmpeg -hide_banner -decoders | grep cuvid
	echo
	$ffmpeg -hide_banner -filters | grep cuda
    fi
    echo
    if [ -e /dev/dri/renderD128 ]
    then
	$ffmpeg -hide_banner -encoders | grep vaapi
	$ffmpeg -hide_banner -encoders | grep qsv
	echo "Decoders"
	$ffmpeg -hide_banner -decoders | grep qsv
	$ffmpeg -hide_banner -filters | grep qsv
	echo "Encoders"
    fi
    echo
    $ffmpeg -hide_banner -encoders | grep h264
    $ffmpeg -hide_banner -encoders | grep hevc
    $ffmpeg -hide_banner -encoders | grep av1
    $ffmpeg -hide_banner -encoders | grep vvc
    $ffmpeg -hide_banner -encoders | grep aac
    $ffmpeg -hide_banner -encoders | grep opus
    $ffmpeg -hide_banner -encoders | grep vorbis
    $ffmpeg -hide_banner -filters | grep vulkan
    echo
    $ffmpeg -hide_banner -demuxers | grep dvdvideo
    exit
}

ls_iso() {
    #set -x
    #echo $1
    #[ "$1" != "" ] && mask="$1"
    e=$(readlink $(which ls))
    if [ "$e" == "" ]
    then
	local ls=ls
	[ "$os" == "FreeBSD" ] && ls=gls
	if [ "$1" != "" ]
	then
	    $ls -lL --time-style long-iso "$1"
	else
	    $ls -lL --time-style long-iso
	fi
    else
	ls -l "$1"
    fi
    #exit
}

input_file() {
    #set -x
    #ls -l --time-style long-iso $INPUT > $old
    name="${INPUT%.*}"
    ifmt=${INPUT##*.}
    if [ "$ifmt" == "rec" ]
    then
	cd "$INPUT"
	INPUT=vdr
	input_vdr
	return
    fi
    #if [ "$(basename $INPUT)" == "VIDEO_TS" ]
    sss="$(basename "$INPUT")"
    if [ "$sss" == "VIDEO_TS" ]
    then
	dvd_path="$INPUT"
	INPUT=dvd
	input_dvd $track
	return
    fi
    oldsize=1
    rec_time=$($date "+%s")
    rm -f $old
    if [ "${INPUT:0:4}" == "http" ]
    then
	#set -x
	ffmpeg_i="-i \"$INPUT\""
	osr=$($ffprobe -i $INPUT 2>&1 | grep "Duration:")
	osd=$(echo $osr|cut -d \  -f 2)
	if [ "$osd" != "N/A," ]
	then
	    oss=$($date -u +%s -d "1970-01-01 ${osd:0:8}")
	    osbr=$(echo $osr|cut -d \  -f 6)
	    #echo $oldsize
	    oldsize=$(($oss*$osbr/8))
	fi
	#exit
    elif [[ "$INPUT" == *+* ]]
    then
	ffmpeg_i="-i concat:"
	oldsize=0
	d=
	IFS="+"
	read I1 _ <<< $INPUT
	for r in $INPUT
	do
	    ffmpeg_i=$ffmpeg_i$d$r
	    d="|"
	    #oldsize=$(($oldsize+$(stat $r -c "%s")))
	    oldsize=$(($oldsize+$(file_size $r)))
	done
	unset IFS
	oldsize=$(($oldsize/1024))
	INPUT=$I1
    #elif [ -e "$name-1.$ifmt" ]	# in progress
    elif [ 1 -eq 2 ]
    then
	#set -x
	ffmpeg_i="-i concat:$INPUT"
	oldsize=$(file_size "$INPUT")
	i=1
	nname="$name-$i.$ifmt"
	while [ -e "$nname" ]
	do
	    ffmpeg_i="$ffmpeg_i|$nname"
	    oldsize=$(($oldsize+$(file_size "$nname")))
	    i=$(($i+1))
	    nname="$name-$i.$ifmt"
	done
	#exit
    else
	if [ ! -e "$INPUT" ]
	then
	    echo "\"$INPUT\" not found."
	    exit 8
	fi
	ffmpeg_i="-i \"$INPUT\""
	ls_iso "$INPUT" > $old
	# -rw-r--r-- 1 ftp ftp 4084731329 13. Mai 2014  exq-12years-720p.mkv
	#oldsize=$(ls -lL "$INPUT"|cut -d \  -f 5)
	oldsize=$(file_size "$INPUT")
	oldsize=$(($oldsize/1024))
	rec_time=$($date "+%s" -r "$INPUT")
    fi
    echo "oldsize="$oldsize >> $old
    input="$INPUT"
    name=$(basename "$name")
    #[ "${ffmpeg_i:${#ffmpeg_i}-1:1}" == \" ] && x=eval
    [ "${ffmpeg_i: -1}" == \" ] && x=eval
    $x $ffmpeg $ffmpeg_i 2> $t
    c_t=$(grep -i creation_time $t|head -n 1|cut -d ':' -f 2-)
    if [ "$c_t" != "" ]
    then
	#set -x
	# 2020-08-19T23:20:35.000000Z
	c_t=${c_t//\"/}
	c_t=${c_t:0:20}
	rec_time=$($date "+%s" -d "$c_t")
	#exit
    fi
    #set -x
    #vencoder=$(grep -i encoder $t|sed -n '2p'|cut -d ':' -f 2-|tr -s ' ' '_')
    #vencoder=$(grep -i encoder $t|sed -n '2p'|cut -d ':' -f 2-)
    #aencoder=$(grep -i encoder $t|sed -n '3p'|cut -d ':' -f 2-|tr -s ' ' '_')
    #[ "${vencoder:1:3}" == "Lav" ] && vencoder=$(echo $vencoder | cut -d \  -f 2)
    #exit
    [ "$odir" != "" ] && dp=$odir/$name/
    dest=$dp$($date "+%F.%H.%M" -d @$rec_time)".3-0.rec"
    d32=0
    while [ -e $dest ]
    do
	d32=$(($d32+1))
	#dest="../"$(date "+%F.%H.%M" -d @$s)".$tr-$d32.rec"
	dest=$dp$($date "+%F.%H.%M" -d @$rec_time)".3-$d32.rec"
    done
    ifmt2="file"
    if [ "$ifmt" == "avi" ]
    then
	#nix=
	OPT_G="$OPT_G -fflags +genpts"
    fi
    #OPT_G="$OPT_G -fflags +igndts+genpts"
    #OPT_G="$OPT_G -fflags +genpts"
    #OPT_G="$OPT_G -use_wallclock_as_timestamps 1"
    if [ "$OUTPUT" == "vdr" ]
    then
	info_name=$(basename "$PWD")
	#n2=$(basename "$(dirname "$PWD")")
	n3=$(dirname "$PWD")
	n2=$(basename "$n3")
	if [ "$n2" != "video" ]
	then
	    info_subt=$info_name
	    info_name=$n2
	fi
	#[ "$chapt_marks" == "1" ] && chapt_marks $INPUT
    fi
    #exit
}

input_chn() {
    #set -x
    #echo $chn $start1
    start=${start1:0:2}":"${start1:2:2}
    starts=$($date "+%s" -d "$start")
    epg=/tmp/$$"_epg"
    svdrpsend lste $chn at $starts | grep ^215 | cut -c5- > $epg
    #cat $epg
    read _ title <<< $(grep ^T $epg)
    echo $title
    oldsize=1
    out_stat=
    chapt_marks=
    wdir=$VIDEODIR/${title//' '/_}
    echo $wdir
    mkdir -p $wdir
    cd $wdir
    #pwd
    ffmpeg_i="-i http://localhost:3000/$chn"
    # E 58389 1741979700 5400 4E 1D
    read _ _ rec_start rec_length _ <<< $(grep "^E " $epg)
    #rec_time=$($date "+%s")
    rec_time=$(($rec_start-300))
    #to=$(($rec_start+$rec_length+1200))
    to=$(($rec_length+1500))
    dest=$dp$($date "+%F.%H.%M" -d @$rec_time)".$chn-1.rec"
    d32=0
    while [ -e $dest ]
    do
	d32=$(($d32+1))
	#dest="../"$(date "+%F.%H.%M" -d @$s)".$tr-$d32.rec"
	dest=$dp$($date "+%F.%H.%M" -d @$rec_time)".$chn-$d32.rec"
    done
    #OPT="$OPT -to $to+"
    OPT="$OPT -to "$(date -u "+%T" -d @$to)
    ifmt=chn
    #exit
}

chk_skip() {
    #set -x
    if [ $oldsize -lt 10000 -a $skip -gt 0 ]
    then
	osr=$($ffprobe $ffmpeg_i 2>&1 | grep "Duration:")
	osd=$(echo $osr|cut -d \  -f 2)
	oss=$($date -u +%s -d "1970-01-01 ${osd:0:8}")
	[ $oss -lt $skip ] && skip=$(($oss/2))
    fi
    #exit
}

input_vdra() {
    #set -x
    if [ ! -e 001.vdr ]
    then
	echo "No vdr recording"
	exit 8
    fi
    ls_iso > $old
    s=$(du)
    oldsize=$(echo $s|cut -d \  -f 1)
    echo "oldsize="$oldsize >> $old
    input=001.vdr
    ffmpeg_i="-f mpeg -i concat:"
    w="0*.vdr"
    d=
    for r in $w
    do
	ffmpeg_i=$ffmpeg_i$d$r
	d="|"
    done
    # 2011-09-26.19.28.40.01.rec
    # 2004-11-21.00:37.50.99.rec
    d1=$(basename $PWD)
    dd1=${d1:0:10}
    #dd=${d1:0:16}
    dh=${d1:11:2}
    dm=${d1:14:2}
    dd=${d1:0:13}"."$dm
    rec_time=$($date "+%s" -u -d "$dd1 $dh:$dm")
    #d3=$(echo $d1 | cut -d '.' -f 4-)
    d3="1-0.rec"
    dp=".."
    dest=../$dd.$d3
    d30=$(echo $d3|cut -d '.' -f 1)
    #d31=$(echo $d30|cut -d '-' -f 1)
    #d32=$(echo $d30|cut -d '-' -f 2)
    IFS=- read d31 d32 <<< $d30
    while [ -e $dest ]
    do
        d32=$(($d32+1))
        #dd2=$(date -u "+%F.%H.%M" -d @$s)
        #dest=$dd2.$d31-$d32.rec
        dest=../$dd.$d31-$d32.rec
    done
    d2=$(dirname $PWD)
    name=$(basename $d2)
    [ ${name:0:1} == "%" ] && name=${name:1}
    [ "$name" == "_" ] && name=video
    #OPT="$OPT -copyts -start_at_zero"
    OPT="$OPT -start_at_zero"
    #OPT_G="$OPT_G -f mpeg"
    [ "$odir" != "" ] && dp=$odir
    name=$dp/$name
    chk_skip
    ifmt="vdr"
    #exit
}

input_vdr() {
    #set -x
    if [ ! -e 00001.ts ]
    then
	input_vdra
	return
	#echo "No vdr recording"
	#exit 8
    fi
    #ls -l --time-style long-iso * > $old
    ls_iso > $old
    #s=$(du -L)
    #oldsize=$(echo $s|cut -d \  -f 1)
    read oldsize _ <<< $(du -L)
    echo "oldsize="$oldsize >> $old
    if [ ! -e revision -a -e dir.txt -a "$apply_codec" == "1" ]
    then
	d=$($date "+%F %T" -r dir.txt)
	read _ os <<< $(head -n 1 dir.txt)
	O=$(grep ^O info)
	echo $d $os >> revision
	echo $d $oldsize $O >> revision
    fi
    input=00001.ts
    # 2018-06-09.14.01.50-0.rec
    #set -x
    w="0*.ts"
    #echo $w
    nw=$(echo $w|wc -w)
    #echo $nw
    if [ $nw -eq 1 ]
    then
	w=$(echo $w)
	ffmpeg_i="-f mpegts -i $w"
    else
	ffmpeg_i="-f mpegts -i concat:"
	d=
	for r in $w
	do
	    ffmpeg_i=$ffmpeg_i$d$r
	    d="|"
	done
    fi
    #exit
    d1=$(basename $PWD)
    d2=$(dirname $PWD)
    name=$(basename $d2)
    dd1=${d1:0:10}
    dd=${d1:0:16}
    dh=${d1:11:2}
    dm=${d1:14:2}
    #set -x
    rec_time=$($date "+%s" -u -d "$dd1 $dh:$dm")
    if [ "$ss" != "" ]
    then
	# ss
	# date -u "+%s" -d "1970-01-01 0:1:50"
	nd=$(echo $ss | grep -o ":" | wc -m)
	case $nd in
	    0)
		ss2=0:0:$ss
		[ $ss -gt 59 ] && ss2=$($date -u "+%T" -d @$ss)
		;;
	    2)
		ss2=0:$ss
		;;
	    4)
		ss2=$ss
		;;
	esac
	ss3=$($date -u "+%s" -d "1970-01-01 $ss2")
	if [ "$ss3" == "" ]
	then
	    echo "-ss $ss wrong"
	    exit 8
	fi
	rec_time=$((rec_time+$ss3))
	#echo $dd
	dd=$($date -u "+%F.%H.%M" -d @$rec_time)
    fi
    #exit
    d3=$(echo $d1 | cut -d '.' -f 4-)
    dp=".."
    if [ "$marker" != "" ]
    then
	dp="../../$name$marker"
    fi
    if [ "$odir" != "" ]
    then
	dp=$odir/$name$marker
	s=$(grep "^S" info)
	if [ "$s" != "" ]
	then
	    s=${s:2}
	    s=$(echo $s|tr -s ' ' '_')	# checkme
	    [[ "$name" == *$s* ]] && serie=1
	    [[ "$s" == *serie* ]] && serie=1
	    if [ "$serie" == "1" ]
	    then
		d0=$(dirname $d2)
		d0=$(basename $d0)
		dp=$odir/$d0/$name
	    fi
	fi
    fi
    #dest=$dp/$dd.$d3
    d30=$(echo $d3|cut -d '.' -f 1)
    #d31=$(echo $d30|cut -d '-' -f 1)
    #d32=$(echo $d30|cut -d '-' -f 2)
    IFS=- read d31 d32 <<< $d30
    vers=$d32
    #set -x
    s=$($ffprobe $ffmpeg_i 2>&1 | grep service_name | cut -d ':' -f 2)
    service_name=$(echo $s)
    #exit
    d32=$(($d32+1))
    dest=$dp/$dd.$d31-$d32.rec
    while [ -e $dest ]
    do
        d32=$(($d32+1))
        #dd2=$(date -u "+%F.%H.%M" -d @$s)
        #dest=$dd2.$d31-$d32.rec
        dest=$dp/$dd.$d31-$d32.rec
    done
    #set -x
    if [ "$select_str" == "" -a $vers == 0 -a ! -e logfile -a -e info ]
    then
	select_str0=0
	C=$(grep ^C info)
	read _ id _ <<< $C
	for (( i=0; i<$chan_sel_i; i++ ))
	do
	    [ "$id" == ${chan_sel_id[$i]} ] && select_str2=${chan_sel[$i]}
	done
	[ "$select_str2" != "" ] && chan_sel_msg="chan_sel=$select_str2"
    fi
    #if [ $chan_set_i -gt 0 -a $vers == 0 -a ! -e logfile -a -e info ]
    if [ $chan_set_i -gt 0 -a $vers == 0 -a -e info ]
    then
	C=$(grep ^C info)
	read _ id _ <<< $C
	for (( i=0; i<$chan_set_i; i++ ))
	do
	    [ "$id" == ${chan_set_id[$i]} ] && parameter ${chan_set[$i]} && chan_set_msg="chan_set=${chan_set[$i]}"
	done
    fi
    if [ $title_set_i -gt 0 -a $vers == 0 -a -e info ]
    then
	T=$(grep ^T info)
	title=${T:2}
	title=${title//' '/_}
	for (( i=0; i<$title_set_i; i++ ))
	do
	    [[ "$title" == *${title_set_id[$i]}* ]] && parameter ${title_set[$i]} && chan_set_msg="title_set=${title_set[$i]}"
	done
    fi
    #exit
    [ ${name:0:1} == "%" ] && name=${name:1}
    [ "$name" == "_" ] && name=video
    [ "$odir" != "" ] && dp=$odir
    name=$dp/$name
    chk_skip
    #OPT_G="$OPT_G -f mpegts"
    ifmt="vdr"
    #exit
}

chapt_mediainfo() {
#set -x
which mediainfo 2> /dev/null
[ $? -ne 0 ] && return
meta=ffmetadata
rm $meta
echo ";FFMETADATA1" > $meta
echo ";mediainfo" >> $meta
mi=mediainfo.txt
mediainfo $1 > $mi
# Duration                                 : 1 h 56 min
# Duration                                 : 10 min 44 s
#dur1=$(grep -m 1 Duration $mi|cut -d ':' -f 2)
#exit
found=0
while read line
do
    if  [ "$line" == "" ]
    then
        found=0
    fi
    if [ $found == 1 ]
    then
        # 00:08:28.333 : Chapter 2
        echo $line
        if [ "${line:0:8}" == "Duration" ]
        then
	    continue
	fi
        if [ "${line:0:4}" == "List" ]
        then
	    break
	fi
	#set -x
        ch=$line
        cht=$(echo $line|cut -d ' ' -f 1)
        chn=$(echo $line|cut -d ' ' -f 3-)
        hh=${cht:0:2}
        mm=${cht:3:2}
        ss=${cht:6:2}
        ms=${cht:9:3}
        s=$($date -u "+%s" -d "1970-01-01 $hh:$mm:$ss")
        #s=$(($s*1000+$ms))
        s="$s$ms"
        if [ "$cha" != "" ]
        then
            echo "[CHAPTER]" >> $meta
            echo "TIMEBASE=1/1000" >> $meta
            echo "START="$sa >> $meta
            echo "#chapter ends at" $cht >> $meta
            #se=$(($s-1))
            echo "END="$s >> $meta
            echo "title="$chna >> $meta
            #exit
        fi
        cha=$ch
        chta=$cht
        chna=$chn
        sa=$s
        #exit
    fi
    if  [ "$line" == "Menu" ]
    then
        found=1
    fi
done < $mi
#set -x
dur=$(grep ^Duration $mi|head -n 1)
# Duration                                 : 1 h 27 min
dur2=$(echo $dur|cut -d ':' -f 2)
h=$(echo $dur2|cut -d \  -f 1)
m=$(echo $dur2|cut -d \  -f 3)
s=$(($h*3600+$m*60))
s=$(($s*1000))
echo "[CHAPTER]" >> $meta
echo "TIMEBASE=1/1000" >> $meta
echo "START="$sa >> $meta
echo "#chapter ends at" $dur2 >> $meta
echo "END="$s >> $meta
echo "title="$chna >> $meta
#exit
}

input_dvd() {
    #echo
    #set -x
    if [ "$dvdvideo" != "" ]
    then
	input_dvdvideo $1
	return
    fi
    #[ "$hwaccel" == "cuvid" ] && parameter --nohw
    tr=1
    [ "$1" != "" ] && tr=$1
    tr2=$(printf "%02d" $tr)
    #ls -l --time-style long-iso * > $old
    if [ "$dvd_path" != "" ]
    then
	#n=${#dvd_path}
	#[ ${dvd_path:$n-1:1} != "/" ] && dvd_path=$dvd_path"/"
	[ ${dvd_path: -1} != "/" ] && dvd_path=$dvd_path"/"
	b=$(basename $dvd_path)
	[ "$b" != "VIDEO_TS" ] && dvd_path=$dvd_path"VIDEO_TS/"
    else
	dvd_path="VIDEO_TS/"
    fi
    #set -x
    rm -f $old
    if [ "${dvd_path:0:5}" == "/mnt/" ]
    then
	p=$(mount | grep $(dirname $dvd_path) | cut -d \  -f 1)
	echo $p > $old
    fi
    ls_iso $dvd_path >> $old
    #exit
    #s=$(du $dvd_path)
    #oldsize=$(echo $s|cut -d \  -f 1)
    ffmpeg_i="-i concat:"
    input=$dvd_path"VTS_"$tr2"_1.VOB"
    ifofile=$dvd_path"VTS_"$tr2"_0.IFO"
    #w="VTS_0"$tr"_*.VOB"
    i=1
    del=
    sum=0
    while [ -e $dvd_path"VTS_"$tr2"_$i.VOB" ]
    do
	r=$dvd_path"VTS_"$tr2"_$i.VOB"
        #echo $r
	#s=$(ls -l $r|cut -d \  -f 5)
	s=$(file_size $r)
	sum=$(($sum+$s))
        ffmpeg_i=$ffmpeg_i$del$r
        del="|"
        i=$(($i+1))
    done
    oldsize=$(($sum/1024))
    echo "oldsize="$oldsize >> $old
    #exit
    #d=$(dirname $PWD)
    d=$PWD
    #name=../$(basename $d)-$tr
    name=$(basename $d)-$tr
    info_name=$(echo $(basename $d)|tr '_' ' ')	# checkme
    ifmt="dvd"
    s=$($date "+%s" -r $dvd_path"VTS_"$tr2"_0.IFO")
    rec_time=$s
    if [ "$OUTPUT" == "vdr" ]
    then
	#set -x
	[ -e ../info.vdr ] && info=../info.vdr
	[ -e info.vdr ] && info=info.vdr
	[ -e $(dirname $dvd_path)/info.vdr ] && info=$(dirname $dvd_path)/info.vdr
	#if [ -e ../info.vdr ]
	if [ "$info" != "" ]
	then
	    e=$(grep "^E" $info)
	    s=$(echo $e|cut -d \  -f 3)
	    rec_time=$s
	fi
	#dest="../"$(date "+%F.%H.%M" -d @$s)".$tr-0.rec"
	dest=$($date "+%F.%H.%M" -d @$s)".$tr-0.rec"
	#exit
	d32=0
	while [ -e $dest ]
	do
	    d32=$(($d32+1))
	    #dest="../"$(date "+%F.%H.%M" -d @$s)".$tr-$d32.rec"
	    dest=$($date "+%F.%H.%M" -d @$s)".$tr-$d32.rec"
	done
    else
	which mediainfo 2> /dev/null
	if [ $? -eq 0 ]
	then
	    [ "$nochapt" != "1" ] && chapt_mediainfo $dvd_path"VTS_"$tr2"_0.IFO"
	fi
    fi
    #OPT_G="$OPT_G -fflags +genpts"
    OPT_G="$OPT_G -fix_sub_duration"
    #exit
}

input_dvdvideo() {
    #set -x
    tr=1
    [ "$1" != "" ] && tr=$1
    tr2=$(printf "%02d" $tr)
    #echo $INPUT
    #echo $dvd_path
    #echo "tr="$tr
    if [ "$dvd_path" != "" ]
    then
	[ ${dvd_path: -1} != "/" ] && dvd_path=$dvd_path"/"
	b=$(basename "$dvd_path")
	[ "$b" != "VIDEO_TS" ] && dvd_path=$dvd_path"VIDEO_TS/"
    else
	dvd_path="VIDEO_TS/"
    fi
    rm -f $old
    if [ "${dvd_path:0:5}" == "/mnt/" ]
    then
	p=$(mount | grep $(dirname $dvd_path) | cut -d \  -f 1)
	echo $p > $old
    fi
    i=1
    sum=0
    while [ -e "$dvd_path""VTS_"$tr2"_$i.VOB" ]
    do
	r="$dvd_path""VTS_"$tr2"_$i.VOB"
        #echo $r
	s=$(ls -l "$r"|cut -d \  -f 5)
	sum=$(($sum+$s))
        i=$(($i+1))
    done
    oldsize=$(($sum/1024))
    if [ $oldsize -eq 0 ]
    then
	olds=$(du "$dvd_path")
	read oldsize _ <<< $olds
    fi
    echo "oldsize="$oldsize >> $old
    ls_iso "$dvd_path" >> $old
    #OPT_G="$OPT_G -f dvdvideo -title $tr"
    ffmpeg_i="-f dvdvideo -title $tr -i $dvd_path"
    ifofile="$dvd_path""VTS_"$tr2"_0.IFO"
    [ ! -e "$ifofile" ] && ifofile=$dvd_path"VTS_01_0.IFO"
    d="$PWD"
    d=$(echo "$d"|tr ' ' '_')
    name="$(basename "$d")-$tr"
    #name=$(echo "$name"|tr '_' ' ')
    #info_name=$(echo $(basename "$d")|tr '_' ' ')	# checkme
    info_name=$(basename "$d")				# checkme
    ifmt="dvd"
    s=$($date "+%s" -r "$ifofile")
    rec_time=$s
    if [ "$OUTPUT" == "vdr" ]
    then
	#set -x
	[ -e ../info.vdr ] && info=../info.vdr
	[ -e info.vdr ] && info=info.vdr
	[ -e "$(dirname "$dvd_path")/info.vdr" ] && info=$(dirname "$dvd_path")/info.vdr
	#if [ -e ../info.vdr ]
	if [ "$info" != "" ]
	then
	    e=$(grep "^E" $info)
	    s=$(echo $e|cut -d \  -f 3)
	    rec_time=$s
	fi
	dest=$($date "+%F.%H.%M" -d @$s)".$tr-0.rec"
	#exit
	d32=0
	while [ -e $dest ]
	do
	    d32=$(($d32+1))
	    dest=$($date "+%F.%H.%M" -d @$s)".$tr-$d32.rec"
	done
    fi
    #OPT_G="$OPT_G -fix_sub_duration"
    #scantype="top first"
    #exit
}

chapt_tsmuxer() {
    #set -x
    meta=ffmetadata
    rm $meta
    echo ";FFMETADATA1" > $meta
    echo ";tsmuxer" >> $meta
    temp=tsmuxer.txt
    tsMuxeR $1 > $temp
    dur=0
    while read line
    do
	if [ "${line:0:6}" == "Marks:" ]
	then
	    marks="$marks ${line:7}"
	fi
	if [ "${line:0:9}" == "Duration:" ]
	then
	    #set -x
	    # Duration: 00:26:47.055
	    dur1=${line:10:8}
	    durs=$($date -u "+%s" -d "1970-01-01 $dur1")
	    dur=$(($dur+$durs))
	    #exit
	fi
	if [ "${line:0:9}" == "Track ID:" ]
	then
	    tid=$(echo $line|cut -d ':' -f 2)
	    tid=$(echo $tid)
	fi
	if [ "${line:0:12}" == "Stream lang:" ]
	then
	    l1=$(echo $line|cut -d ':' -f 2)
	    langa[$tid]=$(echo $l1)
	fi
    done < $temp
    #exit
    ch=0
    for ma in $marks
    do
	#echo $ma
	hh=${ma:0:2}
	mm=${ma:3:2}
	ss=${ma:6:2}
	ms=${ma:9:3}
	#s=$(($h*3600+$m*60))
	s=$($date -u "+%s" -d "1970-01-01 $hh:$mm:$ss")
	s="$s$ms"
	if [ $s -gt 0 ]
	then
	    echo "[CHAPTER]" >> $meta
	    echo "TIMEBASE=1/1000" >> $meta
	    echo "START="$sa >> $meta
	    echo "#chapter ends at" $ma >> $meta
	    echo "END="$s >> $meta
	    echo "title=Chapter "$ch >> $meta
	fi
	ch=$(($ch+1))
	sa=$s
	#exit
    done
    if [ $dur -gt $sa ]
    then
	echo "[CHAPTER]" >> $meta
	echo "TIMEBASE=1/1000" >> $meta
	echo "START="$sa >> $meta
	echo "#chapter ends at" $ma >> $meta
	echo "END="$dur"000" >> $meta
	echo "title=Chapter "$ch >> $meta
    fi
    #exit
}


BD_size() {
    # can be wrong
    #set -x
    p=0
    declare -a size
    size[$2]=1
    fn=0
    sum=0
    f=$(printf "$1/BDMV/STREAM/%05d.m2ts" $fn)
    if [ ! -e $f ]
    then
	fn=1
	f=$(printf "$1/BDMV/STREAM/%05d.m2ts" $fn)
    fi
    while [ -e $f ]
    do
	s=$(ls -l $f|cut -d \  -f 5)
	sum=$(($sum+$s))
	# 4000398
	if [ $s -lt 4000000000 -o $s -gt 4195000000 ]
	then
	    size[$p]=$sum
	    p=$(($p+1))
	    sum=0
	fi
	fn=$(($fn+1))
	f=$(printf "$1/BDMV/STREAM/%05d.m2ts" $fn)
    done
    echo ${size[$2]}
    #exit
}

chapt_BD() {
    chap_list="$bdir/BDMV/META/ES/esmt_deu_0000"$playlist".xml"
    meta=ffmetadata
    rm -f $meta
    echo ";FFMETADATA1" > $meta
    echo ";$chap_list" >> $meta
    echo "title=$fn" >> $meta
    if [ -e $chap_list ]
    then
	#set -x
	while read line
	do
	    #echo $line
	    l=$(echo $line)
	    if [ ${l:0:6} == "<scene" ]
	    then
		#echo $l
		e=${l##*entry_point=}
		e=$(echo $e|cut -d '>' -f 1)
		ctitle=${l##*<name>}
		ctitle=$(echo $ctitle|cut -d '<' -f 1)
		hh=${e:3:2}
		mm=${e:6:2}
		ss=${e:9:2}
		s=$($date -u "+%s" -d "1970-01-01 $hh:$mm:$ss")
		s=$(($s*1000))
		if [ "$sa" != "" ]
		then
		    echo "[CHAPTER]" >> $meta
		    echo "TIMEBASE=1/1000" >> $meta
		    echo "START="$sa >> $meta
		    echo "#chapter ends at" $e >> $meta
		    echo "END="$s >> $meta
		    echo "title="$ctitle_a >> $meta
		fi
		sa=$s
		ctitle_a=$ctitle
	    fi
	done < $chap_list
	#exit
    else
	which tsMuxeRx 2> /dev/null
	if [ $? -eq 0 ]
	then
	    chapt_tsmuxer $mpls
	else
	    which mediainfo 2> /dev/null
	    [ $? -eq 0 ] && chapt_mediainfo $mpls
	fi
    fi
}

chapt_marks_mkv() {
    # Chapter
    [[ "$marks_mkv" == "0" ]] && return
    if [ -e marks ]
    then
	#set -x
	meta=ffmetadata
	echo ";FFMETADATA1" > $meta
	s1=0
	ca=0
	tag=$($date -u +"%s" -d 0:00:00)
	# 0:10:03.48
	while read line _
	do
	    #echo $line
	    c=$($date -u +"%s" -d $line)
	    cs=$(echo $line|cut -d '.' -f 2)
	    ms=$(($cs*10))
	    c=$(($c-$tag))
	    c=$(($c*1000))
	    c=$(($c+$ms))
	    if [ $c -gt $ca ]
	    then
		echo "[CHAPTER]" >> $meta
		#echo "TIMEBASE=1" >> $meta
		echo "TIMEBASE=1/1000" >> $meta
		echo "START=$ca" >> $meta
		echo "#chapter ends at $line" >> $meta
		echo "END=$(($c-1))" >> $meta
		if [ $s1 -eq 0 ]
		then
		    echo "title=Werbung $line" >> $meta
		    s1=1
		else
		    echo "title=Film $line" >> $meta
		    s1=0
		fi
	    fi
	    ca=$c
	done < marks
	#metaf="-i ffmetadata"
	#exit
    fi
}

chapt_marks() {
    #set -x
    local start
    local n
    local nr
    local st
    local ms
    local outm

    if [ "$INPUT" == "dvd" ]
    then
	$ffprobe -hide_banner $ffmpeg_i 2>&1 | grep "Chapter #" > $t
    elif [ "$chapt_marks" == "logfile" ]
    then
	if [ ! -e logfile ]
	then
	    echo logfile not found
	    exit
	fi
	grep "Chapter #" logfile > $t
	dest=.
    else
	$ffprobe -hide_banner "$INPUT" 2>&1 | grep "Chapter #" > $t
    fi
    # Chapter #0:1: start 655.685367, end 2288.816867
    mkdir -p $dest
    outm=$dest/marks
    if [ -e $outm ]
    then
	echo "overwrite $outm? (y/N)"
	read answer
	[ "$answer" != "y" ] && exit
    fi
    while read _ n _ start _
    do
	start=${start//,/}
	#echo $n $start
	IFS=':' read _ nr <<< $n
	IFS='.' read st ms <<< $start
	ms=${ms:0:2}
	#echo $nr $st $ms
	m=$($date -u "+%T" -d @$st)".$ms ($start)"
	echo $m >> $outm
	[ $nr -gt 0 ] && echo $m >> $outm
	#exit
    done < $t
    #exit
}

input_BD() {
    #set -x
    #parameter "--nohw"
    playlist=$1
    #fn=$(basename $PWD)
    #bdir=$dvd_path"/AVCHD"
    bdir=$dvd_path
    #oldsize=1
    details=$bdir/details.txt
    if [ "$playlist" = "" ]
    then
	if [ -e $details ]
	then
	    cat $details
	    iconv -f ISO-8859-1 -t UTF-8 < $details > details.txt
	    i=0
	    while read line
	    do
		echo -n $i" "
		echo $line | cut -d ';' -f 1
		i=$(($i+1))
	    done < details.txt
	fi
	$ffmpeg -hide_banner -i bluray:$bdir 2> $t
	grep -a playlist $t
	exit
    fi
    echo "playlist=$playlist" > $old
    oldsize=$(BD_size $bdir $playlist)
    #oldsize=1
    oldsize=$(($oldsize/1024))
    echo "oldsize="$oldsize >> $old
    ffmpeg_i="-playlist $playlist -i bluray:$bdir"
    d=$PWD
    name=$(basename $d)-$playlist
    if [ -e $details ]
    then
	n=$(($playlist+1))
	z=$(sed -n $n"p" $details)
	echo $z
	name=$(echo $z | cut -d ';' -f 1 | iconv -f ISO-8859-15 -t UTF-8)
	info_name=$name
	name=$(echo $name|tr ' ' '_')	# checkme
    fi
    ifmt="BD"
    mpls=$(printf "$bdir/BDMV/PLAYLIST/%05d.mpls" $playlist)
    [ ! -e $mpls ] && mpls=$(printf "$bdir/BDMV/PLAYLIST/%05d.mpl" $playlist)
    ls_iso $mpls >> $old
    #td=$(ls -l --time-style="+%Y%m%d%H%M" $mpls|cut -d \  -f 6)
    rec_time=$($date -r $mpls "+%s")
    #set -x
    if [ "$OUTPUT" == "vdr" ]
    then
	#set -x
	info=$bdir/vdr/$(($playlist+1))"-info"
	if [ -e $info ]
	then
	    #cat $info
	    e=$(grep "^E" $info)
	    # E 887 1286808000 5400 4E 4
	    rec_time=$(echo $e|cut -d \  -f 3)
	    BD_info=$info
	fi
	#exit
	dest=$name/$($date "+%F.%H.%M" -d @$rec_time)".$playlist-0.rec"
	d32=0
	while [ -e $dest ]
	do
	    d32=$(($d32+1))
	    dest=$name/$($date "+%F.%H.%M" -d @$rec_time)".$playlist-$d32.rec"
	done
    else
	[ "$nochapt" != "1" ] && chapt_BD
	#chapt_tsmuxer $mpls
    fi
    OPT="$OPT -copytb 1"
    #exit
}

set_hwacc() {
    #vaapi_device="-vaapi_device /dev/dri/renderD"$((128+$gpu))
    vaapi_device="-init_hw_device vaapi=/dev/dri/renderD"$((128+$gpu))
    case "$hwaccel" in
	"cuvid")
	    #HWACC="-vsync passthrough -hwaccel cuvid -hwaccel_output_format cuda"
	    HWACC="-hwaccel cuvid -hwaccel_output_format cuda"
	    #[ "$fpso" == "" ] && preenc="-fps_mode passthrough"
	    #HWACC="-hwaccel cuvid -hwaccel_output_format nv12"
	    #HWACC="-hwaccel cuvid -hwaccel_output_format yuv420p"
	    #deinterlace="-vf yadif_cuda"
	    deinterlace="yadif_cuda"
	    [ "$scale" != "" ] && add_vf scale_cuda=$scale
	    #h264enc=h264_nvenc
	    #hevcenc=hevc_nvenc
	    ;;
	"cuda")
	    #HWACC="-hwaccel cuda"
	    #HWACC="-vsync 0 -hwaccel cuda -hwaccel_output_format cuda"
	    HWACC="-hwaccel cuda -hwaccel_output_format cuda"
	    #[ "$fpso" == "" ] && preenc="-fps_mode passthrough"
	    deinterlace="yadif_cuda"
	    [ "$scale" != "" ] && add_vf scale_cuda=$scale
	    ;;
	"vdpau")
	    export DISPLAY=:0.0
	    HWACC="-hwaccel vdpau"
	    [ "$scale" != "" ] && add_vf scale=$scale
	    ;;
	"vaapi")
	    #export LIBVA_DRIVER_NAME=i965
	    [ "$libva" != "" ] && export LIBVA_DRIVER_NAME=$libva
	    VAAPI="$vaapi_device -hwaccel_output_format vaapi"
	    HWACC="-hwaccel vaapi $VAAPI"
	    #deinterlace="-vf 'deinterlace_vaapi=rate=field:auto=1'"
	    deinterlace="deinterlace_vaapi"
	    [ "$scale" != "" ] && add_vf scale_vaapi=$scale
	    ;;
	"qsv")
	    [ "$libva" != "" ] && export LIBVA_DRIVER_NAME=$libva
	    if [ "$vga" != "DG2" ]
	    then
		#HWACC="-hwaccel qsv -hwaccel_output_format qsv -qsv_device /dev/dri/renderD"$((128+$gpu))
		HWACC="-hwaccel qsv -hwaccel_output_format qsv"
		deinterlace="deinterlace_qsv"
		[ "$scale" != "" ] && add_vf scale_qsv=$scale
	    fi
	    #h264enc=h264_qsv
	    #hevcenc=hevc_qsv
	    ;;
	"qsvh")
	    #VAAPI="-vaapi_device /dev/dri/renderD"$((128+$gpu))" -hwaccel_output_format vaapi"
	    #HWACC="-hwaccel vaapi $VAAPI"
	    #HWACC="-init_hw_device qsv=hw -filter_hw_device hw -f rawvideo -pix_fmt yuv420p"
	    HWACC="-init_hw_device qsv=hw"
	    deinterlace="deinterlace_vaapi"
	    [ "$scale" != "" ] && add_vf scale_vaapi=$scale
	    h264enc=h264_qsv
	    hevcenc=hevc_qsv
	    #preenc="-vf hwmap=derive_device=qsv,format=qsv"
	    preenc="-vf hwupload=extra_hw_frames=64,format=qsv"
	    ;;
	"vulkan")
	    #export DISPLAY=:0.0
	    HWACC="-init_hw_device vulkan -hwaccel vulkan -hwaccel_output_format vulkan"
	    deinterlace="bwdif_vulkan"
	    [ "$scale" != "" ] && add_vf scale_vulkan=$scale
	    ;;
	"drm"|"opencl"|"none")
	    HWACC="-hwaccel $hwaccel"
	    ;;
	*)
	    [ "$scale" != "" ] && add_vf scale=$scale
	    ;;
    esac
}


streams() {
    #set -x
    #$ffmpeg -hide_banner $OPT_G $ffmpeg_i 2>&1 | grep "Stream"
    #ffprobe -hide_banner $ffmpeg_i
    #sss="$ffmpeg -hide_banner $OPT_G $ffmpeg_i 2>&1 | grep \"Stream\""
    #eval $sss
    #[ ${ffmpeg_i:${#ffmpeg_i}-1:1} == \" ] && x=eval
    [ ${ffmpeg_i: -1} == \" ] && x=eval
    $x $ffmpeg -hide_banner $OPT_G $ffmpeg_i 2>&1 | grep "Stream"
    exit
}

show_size_x() {
    if [ $1 -lt 5000 ]
    then
	echo "Size:" $1 "kbyte"
    elif [ $1 -lt 4000000 ]
    then
	awk -v "s=$1" 'BEGIN {printf "Size: %.1f Mbyte\n", s/1024+0.05}'
    else
	awk -v "s=$1" 'BEGIN {printf "Size: %.1f Gbyte\n", s/1024/1024+0.05}'
    fi
}

show_size() {
    #echo -n "Size: "
    $numfmt --to=iec --from-unit=1024 --format=%.1f <<< $1
}


inf() {
    #set -x
    #echo "["$ffmpeg_i"]"
    info=info
    if [ -e $info ]
    then
	#sender=$(grep ^C $info|cut -d \  -f 3-)
	read _ chn_id sender <<< $(grep ^C $info)
	O=$(grep ^O $info)
	echo $sender $O
	[ -e $conf ] && [ "$chn_id" != "" ] && grep $chn_id $conf
    fi
    echo -n "Size: "
    show_size $oldsize
    #$ffmpeg $OPT_G $ffmpeg_i 2>&1 | grep -E "Duration|Stream|Chapter"
    #sss="$ffmpeg $OPT_G $ffmpeg_i 2>&1 | grep -E \"Duration|Stream|Chapter\""
    #eval $sss
    #[ "${ffmpeg_i:${#ffmpeg_i}-1:1}" == \" ] && x=eval
    [ "${ffmpeg_i: -1}" == \" ] && x=eval
    [ "$INPUTA" != "" ] && ffmpeg_i="$ffmpeg_i $INPUTA"
    #$x $ffmpeg $OPT_G $ffmpeg_i 2>&1 | grep -E "Duration|Stream|Chapter"
    if [ "$ifmt" == "vdr" -a $skip -gt 0 ]
    then
	set_pid
	$x $ffmpeg $OPT_G $ffmpeg_i 2>&1 | grep -E "Duration"
	#$x $ffmpeg -ss $skip -t 60 $OPT_G $ffmpeg_i -c copy -map 0 $pids -f mpegts - 2> /dev/null | $ffprobe -hide_banner -i - 2>&1 | grep -E "Stream|Chapter"
	$x $ffmpeg -ss $skip -t $(($skip+5)) $OPT_G $ffmpeg_i -c copy -map 0 $pids -f mpegts - 2> /dev/null | $ffprobe -hide_banner -f mpegts -i - 2>&1 | grep -E "Stream|Chapter"
    else
	$x $ffmpeg $OPT_G $ffmpeg_i 2>&1 | grep -E "Duration|Stream|Chapter"
    fi
    #rm -f $t
    #rm -f $old
    #exit
}

set_video() {
    c=$1
    [ "$LIBVA_DRIVER_NAME" != "" ] && echo "LIBVA_DRIVER_NAME=$LIBVA_DRIVER_NAME" >> "$log_c"
    [ "$OUTPUT" == "webm" -a "$ivcodec" != "vp9" -a "$ivcodec" != "vp8" -a "$ivcodec" != "av1" ] && c=vp9
    [ "$vcodec" != "" ] && c=$vcodec
    [ "$OUTPUT" == "vdr" -a $c == "copy" -a "$fpso" != "" ] && c=$ivcodec
    case $c in
	copy)
	    video="-c:v:0 copy $aspect"
	    deinterlace=
	    vf=
	    [ "$OUTPUT" == "mp4" -a "$vencoder" != "" ] && OPT="$OPT -metadata:s:v:0 handler_name=\"$vencoder\""
	    #echo $vf
	    #[ "$vf" == "yadif_cuda" -o "$vf" == "yadif" ] && vf=
	    #exit
	    ;;
	h264)
	    set_h264
	    ;;
	hevc)
	    set_hevc
	    ;;
	vp8)
	    set_vp8
	    ;;
	vp9)
	    set_vp9
	    ;;
	mpeg2)
	    set_mpeg2
	    ;;
	mpeg4)
	    set_mpeg4
	    ;;
	xvid)
	    set_xvid
	    ;;
	av1)
	    set_av1
	    ;;
	avs3)
	    set_avs3
	    ;;
	vvc)
	    set_vvc
	    ;;
	flv)
	    set_flv
	    ;;
	ffv1)
	    set_ffv1
	    ;;
	apv)
	    set_apv
	    ;;
	*)
	    echo "-$ivcodec $1 wrong"
	    exit 8
	    ;;
    esac
    if [ "$OUTPUT" == "vdr" ]
    then
	[ "$c" != "copy" ] && video="$video $gop_vdr"
    else
	[ "$c" != "copy" ] && video="$video $gop_file"
    fi
    if [ "$check" != "" ]
    then
	echo "hwaccel=$hwaccel" > "$log_c.2"
	#[ "$c" == "" ] && c=$vencoder
	#echo "$codec -> $vcodec $c"
	vc=$vcodec
	[ "$vc" == "" ] && vc=copy
	echo $str": $codec -> 0: $vc $vencoder" >> "$log_c.2"
    fi
}

set_h264() {
    #set -x
    [ "$hwaccel" == "vulkan" -a "$h264enc" != "h264_vulkan" ] && hwdownload
    # maxr="-maxrate "$br"k -bufsize 1835k"
    [ "$h264_level" != "" ] && level="-level $h264_level"
    case $h264enc in
	"libx264")
	    #parameter --nohw
	    hwdownload
	    [ "$crf" == "" ] && crf=27
	    #preset="fast"
	    #preset="veryfast"
	    #preset="superfast"
	    #preset="ultrafast"
	    preset="-preset $x264_preset -tune film -profile:v:0 $h264_profile $level -crf $crf $maxr"
	    ;;
	"h264_nvenc")
	    [ "$crf" == "" ] && crf=32
	    [ "$profile" != "" ] && h264_profile=$profile
	    preset="-preset $nvenc_preset -profile:v:0 $h264_profile $level -cq $crf $nvenc_b $maxr"
	    preset="$preset -rc $nvenc_rc"
	    [ "$tier" != "" ] && preset="$preset -tier $tier"
	    #preset="$preset -spatial-aq 1"
	    #preset="$preset -coder 2"
	    #preset="$preset -b_adapt 0"
	    if [ "$pass" != "" ]
	    then
		preset="$preset -2pass 1"
		pass=
	    fi
	    ;;
	"h264_vaapi")
	    #[ "$LIBVA_DRIVER_NAME" != "" ] && echo "LIBVA_DRIVER_NAME=$LIBVA_DRIVER_NAME" >> "$log_c"
	    [ "${v:0:3}" ">" "4.1" ] && rc_mode="-rc_mode CQP"
	    [ "$crf" == "" ] && crf=21
	    preset="-profile:v:0 $h264_profile $level $rc_mode -qp $crf $quality $maxr"
	    [ "$tier" != "" ] && preset="$preset -tier $tier"
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G $vaapi_device" && add_vf 'format=nv12,hwupload'
	    ;;
	"h264_qsv")
	    #LIBVA_DRIVER_NAME=iHD
	    [ "$crf" == "" ] && crf=21
	    #preset="-profile:v $hevc_profile $level -global_quality $crf $opt_r"
	    preset="-profile:v:0 $h264_profile $level -q:v:0 $crf $opt_r"
	    [ "$tier" != "" ] && preset="$preset -tier $tier"
	    ;;
	"h264_vulkan")
	    # under progress
	    #[ "${v:0:3}" ">" "4.1" ] && rc_mode="-rc_mode CQP"
	    [ "$crf" == "" ] && crf=35
	    opt="-usage transcode"
	    preset="-profile:v:0 $h264_profile $rc_mode -qp $crf $quality $opt $maxr"
	    #[ "$hwaccel" == "" ] && OPT_G="$OPT_G -vaapi_device /dev/dri/renderD"$((128+$gpu)) && add_vf 'format=nv12,hwupload'
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G -init_hw_device vulkan" && add_vf 'format=nv12,hwupload'
	    ;;
	"h264_omx")
	    preset="-profile:v:0 high"
	    ;;
	"openh264")
	    h264enc=libopenh264
	    [ "$crf" == "" ] && crf=40
	    #coder="-coder vlc"
	    #coder="-coder cavlc"
	    #coder="-coder cabac"
	    preset="-profile:v:0 $h264_profile -allow_skip_frames 1 -rc_mode quality $coder"
	    preset="$preset -global_quality:v:0 $crf"
	    #preset="$preset -crf $crf"
	    #preset="$preset -qp $crf"
	    ;;
	"h264_amf")
	    #usage=highquality
	    usage=transcoding
	    #quality=quality
	    quality=balanced
	    rc=cqp
	    q="-qp_p $crf -qp_i $crf"
	    #rc=qvbr
	    #q="-qvbr_level $crf"
	    #rc=vbr_peak
	    #q=$h264_br
	    preset="-usage $usage -quality $quality -rc $rc $q"
	    ;;
	"h264_v4l2m2m")
	    preset=
	    ;;
    esac
    #video="-c:v:0 $h264enc $preset $gop $deinterlace $crop $aspect"
    video="$preenc -c:v:0 $h264enc $preset $aspect $h264_br"
    #[ "$OUTPUT" == "vdr" ] && video="$video $gop"
    [ "$hwaccel" == "cuvid" ] && OPT_I="$decode_cuvid"
    [ "$hwaccel" == "mmal" ] && OPT_I="$decode_mmal"
    [ "$hwaccel" == "qsv" ] && OPT_I="$decode_qsv"
    [ "$vcodec" == "" ] && vcodec="h264"
    [ "$OUTPUT" == "mp4" ] && OPT="$OPT -metadata:s:v:0 handler_name=$h264enc"
    #[ "$OUTPUT" == "mp4" ] && OPT="$OPT -metadata comment=vdr-transcode_$h264enc"
    #[ "$OUTPUT" == "vdr" ] && vencoder=$h264enc
    vencoder=$h264enc
    #OPT="$OPT -metadata comment=vdr-transcode_$h264enc"
    #OPT="$OPT -metadata:s:v:0 encoder=$h264enc"
    #exit
}

set_hevc() {
    [ "$s8bit" != "" ] && hwdownload && add_vf format=yuv420p
    [ "$hwaccel" == "vulkan" ] && hwdownload
    [ "$level_hevc" != "" ] && level=$level_hevc
    case "$hevcenc" in
	"libx265")
	    #parameter --nohw
	    #HWACC=
	    #deinterlace="yadif"
	    hwdownload
	    if [ "$libx265_preset" != "" ]
	    then
		preset="$libx265_preset"
	    else
		[ "$x265_preset" == "" ] && x265_preset=$hevc_preset
		[ "$x265_preset" == "" ] && x265_preset=ultrafast
		[ "$hevc_cq" == "" ] && hevc_cq=28
		#x265_params="-x265-params crf=$hevc_cq:level-idc=$hevc_level"
		x265_params="-x265-params crf=$hevc_cq"
		[ "$hevc_level" != "" ] && x265_params="$x265_params:level-idc=$hevc_level"
		[ "$threads" != "" ] && x265_params="-threads $threads "$x265_params":pools=$threads"
		#preset="-preset veryfast $level_hevc -crf $crf $maxr"
		#preset="-preset veryfast $h265_level -crf $hevc_cq $maxr"
		preset="-preset $x265_preset $x265_params -crf $hevc_cq $maxr"
	    fi
	    ;;
	"hevc_nvenc")
	    [ "$hevc_preset" != "" ] && nvenc_preset=$hevc_preset
	    [ "$hevc_cq" == "" ] && hevc_cq=36
	    #hevc_preset=slow
	    [ "$profile" != "" ] && hevc_profile=$profile
	    preset="-preset $nvenc_preset -profile:v:0 $hevc_profile $level -rc $nvenc_rc -cq $hevc_cq $b_ref_mode $opt_r"
	    [ "$tier" != "" ] && preset="$preset -tier $tier"
	    if [ "$pass" != "" ]
	    then
		preset="$preset -2pass 1"
		pass=
	    fi
	    #preset="$preset -init_qpB 25"
	    ;;
	"hevc_vaapi")
	    #LIBVA_DRIVER_NAME=iHD
	    #export LIBVA_DRIVER_NAME=i965
	    #[ "$LIBVA_DRIVER_NAME" != "" ] && echo "LIBVA_DRIVER_NAME=$LIBVA_DRIVER_NAME" >> "$log_c"
	    if [ "$hevc_vaapi_preset" != "" ]
	    then
		preset="$hevc_vaapi_preset"
	    else
		[ "${v:0:3}" ">" "4.1" ] && rc_mode="-rc_mode CQP"
		#[ "${v:0:3}" ">" "4.2" ] && rc_mode="-rc_mode ICQ"
		[ "$hevc_cq" == "" -a "$vga" == "DG2" ] && hevc_cq=28
		[ "$hevc_cq" == "" ] && hevc_cq=32
		preset="-profile:v:0 $hevc_profile $level $rc_mode -qp $hevc_cq $opt_r"
		[ "$tier" != "" ] && preset="$preset -tier $tier"
		#preset="-rc_mode:v CQP -global_quality:v $hevc_cq"
	    fi
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G $vaapi_device" && add_vf 'format=nv12,hwupload'
	    ;;
	"hevc_qsv")
	    #LIBVA_DRIVER_NAME=iHD
	    if [ "$hevc_qsv_preset" != "" ]
	    then
		preset="$hevc_qsv_preset"
	    else
		[ "$hevc_cq" == "" ] && hevc_cq=26
		[ "$hevc_preset" == "" ] && hevc_preset=medium
		load_plugin="-load_plugin hevc_hw"
		#preset="-profile:v $hevc_profile -preset $hevc_preset $level_hevc -q:v $hevc_cq $load_plugin $opt_r"
		preset="-profile:v:0 $hevc_profile -preset $hevc_preset -q:v:0 $hevc_cq $load_plugin $opt_r"
		[ "$tier" != "" ] && preset="$preset -tier $tier"
		#preset="$preset -adaptive_i 1 -adaptive_b 1"
	    fi
	    ;;
	"hevc_vulkan")
	    # under progress
	    #[ "${v:0:3}" ">" "4.1" ] && rc_mode="-rc_mode CQP"
	    #[ "${v:0:3}" ">" "4.2" ] && rc_mode="-rc_mode ICQ"
	    [ "$hevc_cq" == "" -a "$vga" == "DG2" ] && hevc_cq=28
	    [ "$hevc_cq" == "" ] && hevc_cq=32
	    preset="-profile:v:0 $hevc_profile $rc_mode -qp $hevc_cq $opt_r"
	    #preset="-rc_mode:v CQP -global_quality:v $hevc_cq"
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G -init_hw_device vulkan" && add_vf 'format=nv12,hwupload'
	    ;;
	"libkvazaar")
	    #parameter --nohw
	    #hwaccel=
	    #HWACC=
	    #deinterlace="yadif"
	    #decode_cuvid=
	    hwdownload
	    #preset="-profile:v $hevc_profile -kvazaar-params preset=ultrafast,qp=$hevc_cq,level=$hevc_level"
	    [ "$hevc_cq" == "" ] && hevc_cq=28
	    [ "$hevc_preset" == "" ] && hevc_preset=ultrafast
	    #preset="-kvazaar-params preset=ultrafast,qp=$hevc_cq,level=$hevc_level"
	    #preset="-kvazaar-params preset=ultrafast,qp=$hevc_cq,input-bitdepth=10,transfer=bt2020-10"
	    preset="-kvazaar-params preset=$hevc_preset,qp=$hevc_cq"
	    [ "$hevc_level" == "" ] && set_hevc_level
	    if [ "$tier" == "high" ]
	    then
		[ ${hevc_level:0:1} -lt 4 ] && hevc_level=4
		hevc_level="$hevc_level,high-tier"
	    fi
	    [ "$hevc_level" != "" ] && preset="$preset,level=$hevc_level"
	    #[ "$OUTPUT" == "vdr" ] && preset="$preset,gop=$gop_vdr_w"
	    #[ "$OUTPUT" == "vdr" ] && preset="$preset,gop=16"
	    ;;
	"hevc_amf")
	    #usage=highquality
	    usage=transcoding
	    #quality=quality
	    quality=balanced
	    rc=cqp
	    [ "$hevc_cq" != "" ] && q="-qp_p $hevc_cq -qp_i $hevc_cq"
	    preset="-usage $usage -quality $quality -rc $rc $q"
	    ;;
	*)
	    echo "-hevcenc=$hevcenc wrong"
	    exit 8
	    ;;
    esac
    video="$preenc -c:v:0 $hevcenc $preset $aspect $OPT_V"
    #[ "$OUTPUT" == "vdr" ] && video="$video $gop"
    [ "$hwaccel" == "cuvid" ] && OPT_I="$decode_cuvid"
    [ "$hwaccel" == "mmal" ] && OPT_I="$decode_mmal"
    [ "$hwaccel" == "qsv" ] && OPT_I="$decode_qsv"
    [ "$vcodec" == "" ] && vcodec="hevc"
    [ "$OUTPUT" == "mp4" ] && OPT="$OPT -metadata:s:v:0 handler_name=$hevcenc"
    #[ "$OUTPUT" == "vdr" ] && vencoder=$hevcenc
    vencoder=$hevcenc
}

set_vp8() {
    if [ "$OUTPUT" == "vdr" ]
    then
	echo "vdr don´t like vp8"
	exit 8
    fi
    #vp8flags="-vp8flags --cq-level=$gq"
    opt_vp8="-quality good -speed 1 -cpu-used -5"
    video="-c:v:0 libvpx $vp8flags -crf $gq $opt_vp8 $aspect"
    if [ "$hwaccel" == "vaapi" ]
    then
	#LIBVA_DRIVER_NAME=i965
	#[ "$codec" == "mpeg4" ] && parameter --nohw
	video="-c:v:0 vp8_vaapi -rc_mode:v:0 CQP -global_quality:v:0 $gq $aspect"
    #else
	#echo "Only vaapi"
	#exit 8
    fi
}

set_vp9() {
    if [ "$OUTPUT" == "vdr" ]
    then
	echo "vdr don´t like vp9"
	exit 8
    fi
    # crf 0..63
    # crf=33
    # video="-c:v libvpx-vp9 $gop -b:v 0 -crf $crf -threads 16 -tile-columns 6 -frame-parallel 1"
    #if [ "$hwaccel" == "cuvid" ]
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	hwdownload
	#add_vf format=yuv420p
	#add_vf hwdownload
	#add_vf format=nv12
	OPT_I="$decode_cuvid"
    fi
    #[ "$s8bit" != "" ] && add_vf format=yuv420p
    case "$vp9enc" in
	"vp9_vaapi")
	    #export LIBVA_DRIVER_NAME=i965
	    if [ $gq -lt 50 ]
	    then
		gq=120
		echo "gq= changed to $gq" >> "$log_c"
	    fi
	    #[ "$s8bit" != "" ] && hwdownload && add_vf format=yuv420p && add_vf hwupload
	    if [ "$s8bit" != "" ]
	    then
		hwdownload
		add_vf format=yuv420p
		add_vf hwupload
	    fi
	    video="-c:v:0 vp9_vaapi -rc_mode:v:0 CQP -global_quality:v:0 $gq $aspect"
	    #video="-c:v vp9_vaapi -rc_mode:v CQP -global_quality:v $gq -bf -1 -threads $(nproc) $gop $vf $aspect"
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G $vaapi_device" && add_vf 'format=nv12,hwupload'
	    ;;
	"vp9_qsv")
	    #export LIBVA_DRIVER_NAME=iHD
	    if [ $gq -lt 50 ]
	    then
		gq=120
		echo "gq= changed to $gq" >> "$log_c"
	    fi
	    #[ "$s8bit" != "" ] && hwdownload && add_vf format=yuv420p && add_vf hwupload
	    if [ "$s8bit" != "" ]
	    then
		hwdownload
		add_vf format=yuv420p
		add_vf hwupload
	    fi
	    video="-c:v:0 vp9_qsv -profile:v:0 profile0 -preset medium -q:v:0 $gq $aspect"
	    #[ "$hwaccel" == "qsv" ] && add_vf 'hwdownload,format=nv12,hwupload'
	    [ "$hwaccel" == "qsv" ] && OPT_I="$decode_qsv"
	    ;;
	"libvpx-vp9")
	    #crf=33
	    crf=40
	    #video="-c:v libvpx-vp9 $gop -b:v 0 -crf $crf -threads 16 -tile-columns 6 -tile-rows 2 -frame-parallel 1 -cpu-used -5 -row-mt 1 $vf"
	    video="-c:v:0 libvpx-vp9 -b:v:0 0 -crf $crf -threads 16 -speed 4 -frame-parallel 1 -cpu-used -5 -row-mt 1"
	    ;;
	*)
	    echo "-vp9enc=$vp9enc wrong"
	    exit 8
	    ;;
    esac
}

set_av1() {
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" -a "$crop" == "" ]
    then
	hwdownload
	OPT_I="$decode_cuvid"
    fi
    [ "$s8bit" != "" ] && add_vf format=yuv420p
    case "$av1enc" in
	"libaom-av1")
	    aopt="-row-mt 1"
	    #aopt="$aopt -tiles 4x1"
	    aopt="$aopt -tiles 2x2"
	    aopt="$aopt -threads "$(nproc)
	    video="-c:v:0 libaom-av1 -cpu-used 8 -crf $crf $aopt -strict experimental"
	    ;;
	"librav1e")
	    video="-c:v:0 librav1e -rav1e-params speed=9:low_latency=false -threads "$(nproc)" $h264_br"
	    #[ "$h264_br" != "" ] && video="$video "
	    ;;
	"libsvtav1")
	    [ "$hwaccel" != "" ] && hwdownload
	    [ "$av1preset" == "" ] && av1preset=8
	    #if [ ${ffmpeg_v:0:1} -lt 5 ]
	    #then
		[ "$qav1" == "" ] && qav1=55
		video="-c:v:0 $av1enc -preset $av1preset -qp $qav1"
	    #else
		#[ "$qav1" == "" ] && qav1=55
		#video="-c:v:0 $av1enc -preset $av1preset -crf $qav1"
	    #fi
	    #video="$video -svtav1-params fast-decode=2"
	    ;;
	"av1_qsv")
	    #export LIBVA_DRIVER_NAME=iHD
	    if [ "$qav1" == "" ]
	    then
		qav1=135
		echo "av1_q set to $qav1" >> "$log_c"
	    fi
	    preset="-preset fast"
	    [ "$profile" = "" ] && profile=main
	    [ "$av1preset" != "" ] && preset="-preset $av1preset"
	    video="-c:v:0 av1_qsv -profile:v:0 $profile $preset -q:v:0 $qav1 $aspect"
	    #[ "$hwaccel" == "qsv" ] && OPT_G="$OPT_G -qsv_device /dev/dri/renderD"$((128+$gpu)) && add_vf 'format=nv12,hwupload'
	    #[ "$hwaccel" == "qsv" ] && OPT_G="$OPT_G -qsv_device /dev/dri/renderD"$((128+$gpu))
	    #[ "$hwaccel" == "qsv" ] && OPT_G="$OPT_G -init_hw_device qsv:hw,child_device=/dev/dri/renderD"$((128+$gpu))
	    [ "$hwaccel" == "qsv" ] && OPT_G="$OPT_G -init_hw_device vaapi=va:/dev/dri/renderD"$((128+$gpu))" -init_hw_device qsv=hw1@va"
	    ;;
	"av1_vaapi")
	    if [ "$qav1" == "" ]
	    then
		qav1=155
		echo "av1_q set to $qav1" >> "$log_c"
	    fi
	    #rc_mode="-rc_mode ICQ"
	    rc_mode="-rc_mode CQP"
	    video="-c:v:0 av1_vaapi -profile:v:0 main $rc_mode -q:v:0 $qav1 $aspect"
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G $vaapi_device" && add_vf 'format=nv12,hwupload'
	    ;;
	"av1_vulkan")
	    video="-c:v:0 av1_vulkan -usage transcode"
	    [ "$hwaccel" == "" ] && OPT_G="$OPT_G -init_hw_device vulkan" && add_vf 'format=nv12,hwupload'
	    ;;
	*)
	    echo "-av1enc=$av1enc wrong"
	    exit 8
	    ;;
    esac
    video="$video $aspect"
    [ "$OUTPUT" == "mp4" ] && OPT="$OPT -metadata:s:v:0 handler_name=$av1enc"
}

set_vvc() {
    [ "$hwaccel" != "" ] && hwdownload
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" -a "$crop" == "" ]
    then
	#hwdownload
	OPT_I="$decode_cuvid"
    fi
    
    opt="-preset faster"
    #opt="-preset faster -vvenc-params verbosity=3:stats=1:threads=$(nproc)"
    #opt="$opt -vvenc-params verbosity=3:stats=1
    #opt="$opt -vvenc-params InternalBitDepth=8"
    #opt="$opt -vvenc-params OutputBitDepth=8"
    opt="$opt -vvenc-params Sdr=sdr709"
    opt="$opt:version=1"
    #opt="$opt:Threads=$(nproc)"
    #opt="$opt:Verbosity=4"
    opt="$opt -threads $(nproc)"
    [ "$qv" != "" ] && opt="$opt -qp $qv"
    video="-c:v:0 libvvenc $opt"
}

set_avs3() {
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" -a "$crop" == "" ]
    then
	hwdownload
	OPT_I="$decode_cuvid"
    fi
    video="-c:v:0 libuavs3e -thds_frm $(nproc) $aspect"
    [ "$qv" != "" ] && video="$video -qp $qv"
}

set_mpeg2() {
    br="-b:v:0 4000k"
    [ "$h264_br" != "" ] && br=$h264_br
    #add_vf hwupload
    #if [ "$hwaccel" == "cuvid" ]
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	hwdownload
	#add_vf format=nv12
	#add_vf hwdownload
	#add_vf format=nv12
	OPT_I="$decode_cuvid"
    fi
    if [ $vw -gt 720 ]
    then
	video="-c:v:0 mpeg2video $br $aspect"
    else
	video="-c:v:0 mpeg2video $br -dc 9 -flags +ilme+ildct -alternate_scan 1 -top 1 -r 25 $aspect"
	add_vf tinterlace=4
    fi
    #HWACC=
    #[ "$hwaccel" == "cuvid" ] && OPT_I="$OPT_I $decode_cuvid"
    if [ "$OUTPUT" == "vdr" ]
    then
	[ "$aac" == "copy" ] && aac=mp2
	[ "$eac3" == "copy" ] && eac3=ac3
	[ "$mp3" == "copy" ] && mp3=mp2
    fi
}

set_mpeg4() {
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	hwdownload
	OPT_I="$decode_cuvid"
    fi
    video="-c:v:0 mpeg4"
    [ "$mpeg4_b" != "" ] && video="$video -b:v:0 $mpeg4_b"
}

set_xvid() {
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	hwdownload
	OPT_I="$decode_cuvid"
    fi
    #video="-c:v libxvid -flags aic -ssim_acc 0"
    video="-c:v:0 libxvid -flags aic"
    [ "$mpeg4_b" != "" ] && video="$video -b:v:0 $mpeg4_b"
}

set_h263() {
    # in progress
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	hwdownload
	OPT_I="$decode_cuvid"
    fi
    codec="h263p"
    video="-c:v:0 $codec"
}

set_flv() {
    # in progress
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	hwdownload
	OPT_I="$decode_cuvid"
    fi
    opt="-mpv_flags qp_rd -mbd rd"
    codec="flv"
    #codec="h263p"
    #codec="flashsv"
    #codec="flashsv2"
    video="-c:v:0 $codec $opt"
}

set_ffv1() {
    [ "$hwaccel" != "" ] && hwdownload
    if [ "$hwaccel" == "cuvid" -a "$decode_cuvid" != "" ]
    then
	#hwdownload
	OPT_I="$decode_cuvid"
    fi
    opt=
    video="-c:v:0 ffv1 $opt"
}

set_apv() {
    opt=
    [ "$preset" != "" ] && opt="$opt -preset $preset"
    [ "$qv" != "" ] && opt="$opt -qp $qv"
    video="-c:v:0 apv $opt"
}

# Audio

set_aac() {
    if [ "$aaclib" != "libfdk_aac" ]
    then
	chk=$($ffmpeg -hide_banner -encoders | grep fdk)
	if [ "$chk" != "" ]
	then
	    text="=== libfdk_aac installed, but not used ==="
	    echo $text
	    echo $text >> $log_c
	fi
    fi
    if [ "$1" == "he" ]
    then
	[ "$aaclib" != "libfdk_aac" ] && echo "works only with libfdk_aac" && exit 8
	#aac_profile="-profile:$stro aac_he -latm:$stro 1"
	aac_profile="-profile:$stro aac_he"
	[ "$latm" == "" ] && aac_profile="$aac_profile -latm:$stro 1"
	[ "$aac_vbr" == "" ] && aac_vbr=2
	#[ "$OUTPUT" == "vdr" -a "$aac_opt" == "" ] && OPT="$OPT -strict 2 -mpegts_flags latm -flags:a +global_header" && aac_opt=1
	[ "$OUTPUT" == "vdr" -a "$aac_opt" == "" -a "$latm" == "" ] && OPT="$OPT -mpegts_flags latm -flags:a +global_header" && aac_opt=1
    fi
    if [ "$1" == "he_v2" ]
    then
	[ "$aaclib" != "libfdk_aac" ] && echo "works only with libfdk_aac" && exit 8
	#aac_profile="-profile:$stro aac_he_v2 -latm:$stro 1"
	aac_profile="-profile:$stro aac_he_v2"
	[ "$latm" == "" ] && aac_profile="$aac_profile -latm:$stro 1"
	[ "$aac_vbr" == "" ] && aac_vbr=1
	[ "$OUTPUT" == "vdr" -a "$aac_opt" == "" -a "$latm" == "" ] && OPT="$OPT -mpegts_flags latm -flags:a +global_header" && aac_opt=1
    fi
    [ "$aac_vbr" != "" ] && brv="-vbr $aac_vbr"
    #[ "$OUTPUT" == "vdr" -a "$aac_opt" == "" ] && OPT="$OPT -mpegts_flags latm -flags:a +global_header" && aac_opt=1
    #[ "$OUTPUT" == "vdr" -a "$aac_opt" == "" ] && OPT="$OPT -latm 1 -mpegts_flags latm -flags:a +global_header" && aac_opt=1
    #[ "$OUTPUT" == "vdr" -a $ar1 -ne 48000 ] && ar="-ar:$stro 48000"
    if [ "$aac_vbr" != "" ]
    then
	[ "$aaclib" == "libfdk_aac" ] && brv="-vbr $aac_vbr"
	if [ "$aaclib" == "aac" ]
	then
	    brv="-q:$stro $aac_vbr"
	    #br="-vbr $aac_vbr"
	fi
    fi
    if [ "$atyp" != "stereo" -a "$atyp" != "2" -a "$atyp" != "mono" ]
    then
	br="-b:$stro $aac_6ch_br"
	#[ "$aac_vbr" != "" ] && br="-vbr $aac_vbr"
	[ "$brv" != "" ] && br=$brv
	audio_t="-c:$stro $aaclib $aac_profile $br -ac:$stro 6"
    else
	if [ "$ab_str" == "$stro" ]
	then
	    br="-b:$ab_str $ab"
	else
	    [ "$ab_str" == "" ] && br="-b:$stro $aac_stereo_br"
	fi
	[ "$brv" != "" ] && br=$brv
	audio_t="-c:$stro $aaclib $aac_profile $br"
    fi
    [ "$OUTPUT" == "mp4" ] && OPT="$OPT -metadata:s:$stro handler_name=$aaclib"
    aencoder=$aaclib
}

set_opus() {
    if [ "$OUTPUT" == "vdr" ]
    then
	echo "opus not supported by vdr"
	exit 8
    fi
    # Stream #0:3[0x81]: Audio: ac3, 48000 Hz, 5.0(side), fltp, 448 kb/s
    # 5.1(side)
    #abr=64000
    #[ "$opus_br" != "" ] && abr=opus_br
    abr=$((opus_br*1000))
    [ "$atyp" != "stereo" -a "$atyp" != "2" -a "$atyp" != "mono" ] && abr=$(($abr*3))
    [ "$atyp" == "mono" ] && abr=$(($abr/2))
    ch=
    [ "${atyp:0:3}" == "5.0" ] && ch="-ac:$stro 6"
    [ "${atyp:0:3}" == "6.1" ] && ch="-ac:$stro 6"
    [ "${atyp:0:3}" == "7.1" ] && ch="-ac:$stro 6"
    audio_t="-c:$stro libopus -vbr on -b:$stro $abr $ch"
    [ "$atyp" == "5.1(side)" ] && audio_t="$audio_t -ac:$stro 6"
}

set_vorbis() {
    audio_t="-c:$stro libvorbis"
    [ "$ab" != "" ] && audio_t="$audio_t -b:$stro $ab"
}

set_ac3() {
    if [ "$atyp" != "stereo" -a "$atyp" != "2" ]
    then
	audio_t="-c:$stro ac3 -b:$stro 448k"
    else
	audio_t="-c:$stro ac3 -b:$stro 192k"
    fi
    audio_t="$audio_t -dialnorm:$stro $dnorm"
}

set_eac3() {
    if [ "$atyp" != "stereo" -a "$atyp" != "2" ]
    then
	audio_t="-c:$stro eac3 -b:$stro 256k"
    else
	audio_t="-c:$stro eac3 -b:$stro 128k"
    fi
    audio_t="$audio_t -dialnorm:$stro $dnorm"
}

set_dts() {
    br="768k"
    [ "$dts_br" != "" ] && br=$dts_br
    audio_t="-strict -2 -c:$stro dca -b:$stro $br"
}

set_mp2() {
    audio_t="-c:$stro libtwolame -b:$stro 192k"
}

set_mp3() {
    audio_t="-c:$stro mp3 $mp3_b"
}

set_mlp() {
    audio_t="-c:$stro mlp -strict -2"
}

set_truehd() {
    audio_t="-c:$stro truehd -strict -2"
}

core(){
    case $codec in
	"dts")
	    core="dca_core"
	    ;;
	"truehd")
	    core="truehd_core"
	    #audio_t="-c:$stro truehd -bsf:$stro truehd_core -strict -2"
	    ;;
	"eac3")
	    core="eac3_core"
	    ;;
    esac
    [ "$core" != "" ] && audio_t="-c:$stro copy -bsf:$stro $core"
}

set_audio_plus() {
    map="$map -map $str0:$str"
    audio="$audio -c:$stro copy"
    [ "$check" != "" ] && echo $str": $codec -> "$stro": copy" >> "$log_c.2"
    stro1=$(($stro1+1))
    stro=$stro1
    codec1=${codec1:1}
}

set_audio() {
    #set -x
    local upm
    codec1=$1
    [ ${codec1:0:1} == "+" ] && set_audio_plus
    [ "$achannels" != "" ] && atyp=stereo
    #[ "$achannels" == "2" ] && OPT="$OPT -filter:$stro pan=stereo|c0=FL|c1=FR"
    [ "$OUTPUT" == "vdr" -a $ar1 -ne 48000 ] && ar="-ar:$stro 48000"
    if [ "$upmix" != "" ]
    then
	if [ "$atyp" == "stereo" ]
	then
	    #upm="-af:$stro surround -ac:$stro 6"
	    if [ "$win_func" == "" ]
	    then
		#upm="-filter:$stro surround -ac:$stro 6"
		upm="-filter:$stro surround=flx=4:frx=4:fc_out=1.3 -ac:$stro 6"
	    else
		upm="-filter:$stro surround=win_func=$win_func -ac:$stro 6"
	    fi
	    #upm="-filter:$stro surround=chl_in=downmix -ac:$stro 6"	# Unsupported upmix
	    #upm="-filter:$stro surround=chl_in=DL+DR -ac:$stro 6"	# Unsupported upmix
	    atyp="5.1"
	fi
    fi
    if [ "$codec" == "ac3" -a "$codec1" == "copy" ]
    then
	if [ "$atyp" == "stereo" -a "$ac3_stereo" != "" ]
	then
	#    [ $bra -gt 192 -a "$ac3_stereo" == "aac" ] && codec1=aac
	#    [ $bra -gt 192 -a "$ac3_stereo" == "aac_he" ] && codec1=aac_he
	#    #[ "$ac3v" != "" -a $bra -eq 192 ] && audio_t="-c:$stro $aaclib -b:$s
	    [ $bra -gt $ac3_stereo_level ] && codec1=$ac3_stereo
	    #[ $bra -eq $ac3_stereo_level -a "$ac3_1" == "stereo" ] && codec1=$ac3_stereo
	    [ "$str" -gt 1 ] && [ $bra -eq $ac3_stereo_level -a "$atyp_1" == "stereo" -a "$ac3_stereo" != "ac3" ] && codec1=$ac3_stereo # checkme
	fi
    fi
    [ "$acodec" != "" ] && codec1=$acodec
    [ "${acodeca[$str]}" != "" ] && codec1=${acodeca[$str]}
    #exit
    case $codec1 in
	"copy")
	    audio_t="-c:$stro copy"
	    ;;
	"pcm")
	    audio_t="-c:$stro pcm_s16le"
	    ;;
	"pcm_s16be")
	    audio_t="-c:$stro pcm_s16be"
	    ;;
	"core")
	    core
	    ;;
	"ac3")
	    set_ac3
	    ;;
	"eac3")
	    set_eac3
	    ;;
	"aac")
	    set_aac
	    ;;
	"aac_he")
	    set_aac he
	    ;;
	"aac_he_v2"|"aac_v2")
	    set_aac he_v2
	    ;;
	"opus")
	    set_opus
	    ;;
	"dts")
	    set_dts
	    ;;
	"mp2")
	    set_mp2
	    ;;
	"mp3")
	    set_mp3
	    ;;
	"vorbis")
	    set_vorbis
	    ;;
	"mlp")
	    set_mlp
	    ;;
	"truehd")
	    set_truehd
	    ;;
	*)
	    msg="$codec1 wrong"
	    echo $msg
	    echo $msg >> $log_c
	    exit 8
	    ;;
    esac
    [ "$upm" != "" ] && audio_t="$audio_t $upm"
    [ "$check" != "" ] && echo $str": $slang $codec -> "$stro": $codec1 $aencoder $ab" >> "$log_c.2"
    audio_t="$audio_t $ar"
    #exit
    }

set_pid() {
    v=$($ffprobe -hide_banner $ffmpeg_i 2>&1 | grep "Video:")
    IFS='[]' read pre pidx post <<< $v
    [ "${pidx:0:2}" != "0x" ] && return
    PID=$(($pidx))
    pids="-mpegts_start_pid $PID"
}

check_scantype_ffmpeg() {
	echo "Check scantype with ffmpeg" >> "$log_c"
	# ffprobe -hide_banner -show_streams <input> | grep field_order=
	#s1=$(grep "Video:" $t)
	# Stream #0:0[0x96a]: Video: hevc (Main)
	#codec=$(echo $s1|cut -d \  -f 4)
	#codec=${codec//,/}
	# top first
	#if [[ "$s1" == *progressive* ]]
	#if [[ "$s1" == *"top first"* ]]
	if [[ "$s1" == *" first"* ]]
	then
	    scantype="not progr"
	else
	    scantype="Progressive"
	fi
	#[ "$ivcodec" == "hevc" ] && scantype="Progressive"
	#echo "ivcodec=$ivcodec"
}

show() {
    [ "$1" != "" ] && echo $1
}

set_hevc_level() {
    if [ "$vw" != "" ]
    then
	[ $vw -le 576 ] && hevc_level=3.1
	[ $vw -ge 720 ] && hevc_level=4.1
	[ $vw -ge 1080 ] && hevc_level=4.1
	[ $vw -gt 2000 ] && hevc_level=5.1
	[ $vw -gt 2160 ] && hevc_level=6.0
    fi
}

analyze() {
    #set -x
    local s
    [ "$trace" != "" ] && >&2 ls -l $t
    [ "$check" != "" ] && echo "Size: "$(show_size $oldsize)
    #$ffprobe -hide_banner $ffmpeg_i 2>&1 | grep "Stream" > $t
    #sss="$ffprobe -hide_banner $ffmpeg_i 2>&1 | grep "Stream" > $t"
    #eval $sss
    #[ "${ffmpeg_i:${#ffmpeg_i}-1:1}" == \" ] && x=eval
    [ "${ffmpeg_i: -1}" == \" ] && x=eval
    #[ "$auto" != "" ] && x="nohup $x"
    if [ "$INPUTA" != "" ]
    then
	if [ "$ifmt" != "vdr" ]
	then
	    #ffmpeg_i="$ffmpeg_i -i \"$INPUTA\""
	    ffmpeg_i="$ffmpeg_i $INPUTA"
	else
	    ffmpeg_i="$ffmpeg_i $INPUTA"
	fi
	#map="$map -map 1:a"
	#audio="$audio -c:a copy"
	#[ "${lang[2]}" != "" ] && OPT="$OPT -metadata:s:2 language=${lang[2]}"
	$x $ffmpeg -hide_banner $ffmpeg_i 2>&1 | grep "Stream" > $t
    else
	#$x $ffprobe -hide_banner $ffmpeg_i 2>&1 | grep "Stream" > $t
	[ "$auto" != "" ] && optp="-nostdin"
	if [ "$ifmt" == "vdr" -a $skip -gt 0 ]
	then
	    set_pid
	    $x $ffprobe -hide_banner $OPT_G $ffmpeg_i 2>&1 | grep "Duration" > $t
	    $x $ffmpeg $optp -hide_banner -ss $skip -t 60 $ffmpeg_i -c copy -map 0 $pids -f mpegts - 2> /dev/null | $ffprobe -hide_banner -i - 2>&1 | grep "Stream" >> $t
	else
	    $x $ffprobe -hide_banner $OPT_G $ffmpeg_i 2>&1 | grep -E "Stream|Duration" > $t
	fi
    fi
    OPT_G="$OPT_G $OPT_G2"
    [ "$INPUTC" != "" ] && ffmpeg_i="$ffmpeg_i -i \"$INPUTC\""
    #cat $t
    dur_line=$(grep Duration: $t)
    read _ dur _ _ _ bitr1 _ <<< $dur_line
    #echo $dur $bitr1
    #exit
    [ "$trace" != "" ] && >&2 cat $t
    #set -x
    echo "Analyze:" >> "$log_c"
    #set -x
    s1=$(grep "Video:" $t)
    # Stream #0:0[0x96a]: Video: hevc (Main)
    codec=$(echo $s1|cut -d \  -f 4)
    ivcodec=${codec//,/}
    if [ "$ifmt" == "vdr" ]
    then
	if [ -e info ]
	then
	    lf=$(grep ^F info)
	    [ "$lf" != "" ] && read _ fpsv hw vw s aspecti _ <<< $lf
	    if [ "$s" != "" ]
	    then
		echo "Scantype $s found in info" >> $log_c
		[ "$s" != "-" ] && scantype=$s
		[ "$s" == "p" ] && scantype="Progressive"
	    fi
	    #echo $fpsv
	fi
    fi
    if [ "$ivcodec" == "hevc" ]
    then
	scantype="Progressive"
	echo "hevc -> Progressive" >> $log_c
    fi
    #exit
    if [ "$scantype" == "" ]
    then
	which mediainfo 2> /dev/null > /dev/null 
	if [ $? -eq 0 -a "${INPUT:0:4}" != "http" ]
	then
	    echo "Check scantype with mediainfo" >> "$log_c"
	    scantype=$(mediainfo --Inform="Video;%ScanType/String%" "$input")
	    scanorder=$(mediainfo --Inform="Video;%ScanOrder/String%" "$input")
	    [ "$scanorder" != "" ] && scantype=$scanorder
	    if [ "$ifofile" != "" ]
	    then
		echo -n "Duration: " >> "$log_c"
		mediainfo --Inform="General;%Duration/String3%" $ifofile >> "$log_c"
	    fi
	    hw=$(mediainfo --Inform="Video;%Width%" "$input")
	    vw=$(mediainfo --Inform="Video;%Height%" "$input")
	    [ "$scantype" == "" ] && check_scantype_ffmpeg
	else
	    #echo "mediainfo missing, trying ffmpeg" >> "$log_c"
	    #echo "trying ffmpeg" >> "$log_c"
	    check_scantype_ffmpeg
	fi
    fi
    echo "scantype=$scantype" >> "$log_c"
    if [ "$scantype" == "Progressive" -o "$scantype" == "" ]
    then
	deinterlace=
    else
	#opt_r="-r 50"
	opt_r=""
    fi
    [ "$OUTPUT" == "mpg" ] && deinterlace=
    [ "$OUTPUT" == "avi" ] && deinterlace=
    if [ "$deinterlace" != "" ]
    then
	#deinterlace=$deinterlace"=mode=1"
	deinterlace=$deinterlace$deint_mode
    fi
    echo "deinterlace=$deinterlace" >> "$log_c"
    #exit
    if [ "$hwaccel" != "vaapi" ]
    then
	[ "$deinterlace" != "" ] && add_vf $deinterlace
    fi
    #[ "$crop" != "" ] && hwdownload && add_vf $crop
    if [ "$crop" != "" ]
    then
	hwdownload
	add_vf $crop
    fi
    #[ "$vf" != "" ] && vf="-vf $vf"
    #exit
    # vdr
    # Stream #0:0[0x100]: Video: h264 (High) ([27][0][0][0] / 0x001B), yuv420p(tv, bt709, progressive), 1280x720 [SAR 1:1 DAR 16:9], 50 fps, 50 tbr, 90k tbn, 100 tbc
    # Stream #0:1[0x101](deu): Audio: ac3 ([6][0][0][0] / 0x0006), 48000 Hz, stereo, fltp, 384 kb/s
    # Stream #0:2[0x106](deu): Subtitle: dvb_subtitle ([6][0][0][0] / 0x0006)
    # mp4
    # Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(tv, bt709), 1280x720 [SAR 1:1 DAR 16:9], 7278 kb/s, 50 fps, 50 tbr, 90k tbn, 100 tbc (default)
    # Stream #0:1(deu): Audio: ac3 (ac-3 / 0x332D6361), 48000 Hz, stereo, fltp, 384 kb/s (default)
    # Stream #0:2(deu): Subtitle: dvd_subtitle (mp4s / 0x7334706D), 720x480, 9 kb/s (default)
    # mkv
    # Stream #0:0: Video: h264 (High), yuv420p(tv, bt709, progressive), 1280x720 [SAR 1:1 DAR 16:9], 50 fps, 50 tbr, 1k tbn, 100 tbc (default)
    # Stream #0:1(deu): Audio: ac3, 48000 Hz, stereo, fltp, 384 kb/s (default)
    # Stream #0:2(deu): Subtitle: dvb_subtitle (default)
    # avi
    # Stream #0:0: Video: msmpeg4v3 (DIV3 / 0x33564944), yuv420p, 576x240, 719 kb/s, 25 fps, 25 tbr, 25 tbn, 25 tbc
    # Stream #0:1: Audio: mp3 (U[0][0][0] / 0x0055), 44100 Hz, stereo, fltp, 127 kb/s
    # dvd
    # Stream #0:0[0x1bf]: Data: dvd_nav_packet
    # Stream #0:1[0x1e0]: Video: mpeg2video (Main), yuv420p(tv, progressive), 720x576 [SAR 64:45 DAR 16:9], 25 fps, 25 tbr, 90k tbn, 50 tbc
    # Stream #0:2[0x81]: Audio: ac3, 48000 Hz, 5.1(side), fltp, 384 kb/s
    # Stream #0:2[0xa0]: Audio: pcm_dvd, 48000 Hz, 2 channels, s16, 1536 kb/s
    # Stream #0:0[0x1bf]: Data: dvd_nav_packet
    #
    # Stream #0:0[0x1e0]: Video: mpeg2video, yuv420p(tv, top first), 720x576, SAR 64:45 DAR 16:9, 25 fps, 25 tbr, 90k tbn
    # Stream #0:1[0x80](ger): Audio: ac3, 48000 Hz, 5.1(side), fltp, 448 kb/s
    # mpg
    # Stream #0:0[0x1e0]: Video: mpeg2video (Main), yuv420p(tv, fcc/bt470bg/bt470bg, top first), 480x576 [SAR 8:5 DAR 4:3], 25 fps, 25 tbr, 90k tbn, 50 tbc
    # Stream #0:1[0x1c0]: Audio: mp2, 44100 Hz, stereo, s16p, 128 kb/s
    #
    # Stream #0:3(ger): Audio: eac3, 48000 Hz, 2 channels, fltp
    # Stream #0:0(eng): Video: av1 (Main), none, 1280x720, SAR 1:1 DAR 16:9, 25 fps, 25 tbr, 1k tbn, 1k tbc (default)
    # Stream #1:0: Audio: mp2, 48000 Hz, stereo, fltp, 192 kb/s
    # UHD
    # Stream #0:0: Video: hevc (Main 10) (hev1 / 0x31766568), yuv420p10le(tv, bt2020nc/bt2020/arib-std-b67), 3840x2160 [SAR 1:1 DAR 16:9], q=2-31, 50 fps, 50 tbr, 12800 tbn, 25 tbc
    #
    # Stream #0:2(eng): Audio: pcm_s16le ([1][0][0][0] / 0x0001), 48000 Hz, 5.1(side), s16, 4608 kb/s

    #set -x
    #sel_best=1
    if [ "$sel_best" != "" ]
    then
	grep "Audio:" $t > $t"-a"
	brb=0
	while read line
	do
	    #line2=${line//,/}
	    #read w1 _ typ codec _ <<< $line2
	    str1=${line#*:}
	    str=${str1%%[*}
	    bra1=${line%kb/s*}
	    #echo ${#line} ${#bra1}
	    [ ${#line} -eq ${#bra1} ] && continue
	    nw=$(echo $bra1|wc -w)
	    bra=$(echo $bra1|cut -d \  -f $nw)
	    if [ "$bra" != "" ]
	    then
		re='[0-9]'
		if [[ "$bra" =~ $re ]]
		then
		    # fltp
		    # re='[0-9]'; [[ "1" =~ $re ]] && echo 1
		    #echo "bra=["$bra"]"
		    if [ $bra -gt $brb ]
		    then
			brb=$bra
			sel=$str
		    fi
		fi
	    fi
	done < $t"-a"
	select_str2=$sel
	echo "select_str2="$sel
    fi
    if [ "$sel_best" == "eac3" ]
    then
	grep "Audio:" $t > $t"-a"
	while read line
	do
	    line2=${line//,/}
	    read w1 _ typ codec _ <<< $line2
	    [ "$codec" == "eac3" ] && sel=$str
	done < $t"-a"
	select_str2=$sel
	echo "select_str2="$sel
    fi
    #exit
    [ "$trace" != "" ] && >&2 cat $t
    map="-map 0:v:0"
    stro1=1
    str_s=-1
    bras=0
    while read line
    do
	#echo $line
	[ "$check" != "" ] && echo $line
	stro=$stro1
	line2=${line//,/}
	#w1=$(echo $line2|cut -d \  -f 1)
	read w1 stream typ codec _ <<< $line2
	[ "$w1" != "Stream" ] && continue
	#codec=$(echo $line|cut -d \  -f 4)
	#codec=${codec//,/}
	#typ=$(echo $line|cut -d \  -f 3)
	#set -x
	str0=${stream%%:*}
	#str0=${str0:${#str0}-1:1}
	str0=${str0: -1}
	str1=${stream#*:}
	#set -x
	IFS='()' read _ slang _ <<< $str1
	#echo $slang
	#[ "${slang:0:1}" == "[" ] && slang=
	if [[ "$str1" == *[0x* ]]
	then
	    #set -x
	    str=${str1%%[*}
	    trid=${stream#*[}
	    trid=${trid%%]*}
	    #[ "${langa[$(($trid))]}" != "" ] && metal="$metal -metadata:s:$stro language=${langa[$(($trid))]}"
	    #exit
	else
	    str=${str1%%(*}
	    str=${str%%:*}
	fi
	#set +x
	if [ "$ifmt" == "wmv" ]
	then
	    str=${str1%%(*}
	    str=${str%%:*}
	fi
	#exit
	[ "$ifmt" == "avi" ] && str=${str1%%:*}
	#exit

	[ "$typ" == "Subtitle:" ] && str_s=$(($str_s+1))

	#if [ "$select_str2" != "" -a "$typ" != "Video:" ]
	if [ "$select_str2" != "" -a "$select_str0" == "$str0" -a "$typ" != "Video:" ]
	then
	    IFS=,
	    ok=0
	    for s in $select_str2
	    do
		[ $str == $s ] && ok=1
	    done
	    unset IFS
	    [ $str == 0 ] && ok=1
	    [ $ok == 0 ] && continue
	fi
	
	if [ "$sell" != "" -a "$slang" != "" ]
	then
	    #set -x
	    #echo $sell
	    #echo $slang
	    [[ ! "$sell" == *$slang* ]] && continue
	    #exit
	fi

	if [ "$typ" == "Video:" -a "$codec" != "mjpeg" ]
	then
	    #set -x
	    [ $str0 -gt 0 ] && continue
	    #[ "$ivcodec" != "" ] && continue
	    IFS=, read _ vtyp _ <<< $line
	    vtyp=$(echo $vtyp)
	    if [[ "$vtyp" == *\(* ]]
	    then
		IFS="(" read vtyp _ <<< $vtyp
	    fi
	    #echo "[$vtyp]"
	    #set -x
	    if [ "$fpsv" != "" ]
	    then
		fps=$fpsv
	    else
		fps1=${line%fps*}
		nw=$(echo $fps1|wc -w)
		fps=$(echo $fps1|cut -d \  -f $nw)
	    fi
	    #exit
	    ivcodec=$codec
	    #echo "deinterlace=$deinterlace" >> "$log_c"
	    #eval ovcodec=$$ivcodec
	    #echo $vcodec
	    #exit
	    #if [ "$hwaccel" != "vaapi" ]
	    #then
		#[ "$deinterlace" != "" ] && add_vf $deinterlace
	    #fi
	    if [ "$OUTPUT" == "mp3" ]
	    then
		video="-vn"
		map=
		continue
	    fi
	    if [ "$OUTPUT" == "vdr" ]
	    then
		#[ "$fps" == "23.98" ] && add_vf "fps=25"
		#[ "$fps" == "29.97" ] && add_vf "fps=50"
		#[ $fps -lt 25 ] && add_vf "fps=25" && fpso=25
		[ "$fps" "<" "25" ] && add_vf "fps=25" && fpso=25
		#[ $fps -gt 25 ] && add_vf "fps=50" && fpso=50
		[ "$fps" ">" "25" -a "$fps" != "50" ] && add_vf "fps=50" && fpso=50
	    fi
	    #[ "$vf" != "" ] && vf="-vf $vf"
	    #set -x
	    if [ "$vw" == "" ]
	    then
		# ffprobe -hide_banner -show_streams
		# Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(tv, bt709), 1920x1080 [SAR 1:1 DAR 16:9], 7296 kb/s, 50 fps, 50 tbr, 12800 tbn, 100 tbc (default)
		# Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(tv, bt709), 1920x1080, 5531 kb/s, 50 fps, 50 tbr, 12800 tbn, 100 tbc (default)
		# Stream #0:0(eng): Video: av1 (Main), none, 1280x720, SAR 1:1 DAR 16:9, 25 fps, 25 tbr, 1k tbn, 1k tbc (default)
		# Stream #0:0(eng): Video: vp9 (Profile 0), yuv420p(tv, bt709), 1920x1080, SAR 1:1 DAR 16:9, 23.98 fps, 23.98 tbr, 1k tbn (default)
		hw=${line%%[SAR*}	# checkme
		nw=$(echo $hw|wc -w)
		hw=$(echo $hw|cut -d \  -f $nw)
		if [[ ! "$hw" == *x* ]]
		then
		    hw=${line%%, SAR*}
		    nw=$(echo $hw|wc -w)
		    hw=$(echo $hw|cut -d \  -f $nw)
		fi
		#vw=$(echo $hw|cut -d 'x' -f 2)
		#hw=$(echo $hw|cut -d 'x' -f 1)
		IFS=x read hw vw <<< $hw
	    fi
	    if [ "$scale" != "" ]
	    then
		#echo $scale
		#hw=$(echo $scale|cut -d ':' -f 1)
		#vw=$(echo $scale|cut -d ':' -f 2)
		IFS=: read hw vw <<< $scale
	    fi
	    if [ "$vw" != ""  -a "x" == "y" ]
	    then
		[ $vw -le 576 ] && h264_level=3.1
		[ $vw -ge 1080 ] && h264_level=4.2
		[ $vw -gt 2000 ] && hevc_level=5.1 && level_hevc="-level $hevc_level" && h264_level=5.2
		[ $vw -gt 2160 ] && hevc_level=6.0 && level_hevc="-level $hevc_level" && h264_level=5.2
	    fi
	    #exit
	fi
	if [ "$typ" == "Audio:" ]
	then
	    #set -x
	    aencoder=
	    echo $line >> "$log_c"
	    atyp1=${line2#*Hz*}
	    atyp=$(echo $atyp1 | cut -d ' ' -f 1)
	    atyp=${atyp//,/}
	    [ "$str" == 1 ] && atyp_1=$atyp
	    bra1=${line%kb/s*}
	    if [ ${#line} -ne ${#bra1} ]
	    then
		nw=$(echo $bra1|wc -w)
		bra=$(echo $bra1|cut -d \  -f $nw)
		#bras=$(($bras+$bra))
	    else
		bra=0
	    fi
	    ar1=${line%Hz*}
	    nw=$(echo $ar1|wc -w)
	    ar1=$(echo $ar1|cut -d \  -f $nw)
	    #IFS=, read _ ar2 atyp _ bra2 <<< $line
	    #echo "[$ar2][$atyp][$bra2]"
	    #set -x
	    [ "${lang[$str]}" != "" ] && OPT="$OPT -metadata:s:$stro language=${lang[$str]}"
	    [ "${streamo[$str]}" != "" ] && str=${streamo[$str]}
	    #exit
	    if [ "$default" != "" ]
	    then
		#set -x
		IFS='()' read _ lang _ <<< $line
		echo $lang
		if [ "$lang" == "$default" ]
		then
		    OPT="$OPT -disposition:$stro default"
		else
		    OPT="$OPT -disposition:$stro 0"
		fi
		#exit
	    fi
	    [ "$dpl" == "$str" ] && OPT="$OPT -dsur_mode:$stro 2"
	    [ "${volumea[$str]}" != "" ] && OPT="$OPT -filter:$stro volume=${volumea[$str]}"
	    [ "${dispa[$str]}" != "" ] && OPT="$OPT -disposition:$stro ${dispa[$str]}"
	    [ "${dsura[$str]}" != "" ] && OPT="$OPT -dsur_mode:$stro ${dsura[$str]}"
	fi
	if [ "$typ" == "Subtitle:" ]
	then
	    [ "${lang[$str]}" != "" ] && OPT="$OPT -metadata:s:$stro language=${lang[$str]}"
	fi
	case $codec in
	    "mpeg2video"|"mpeg1video")
		#set -x
		video="-c:v:0 copy"
		#decode_cuvid="-c:v mpeg2_cuvid"
		decode_cuvid="-c:v:0 ${codec:0:5}_cuvid"
		decode_qsv="-c:v:0 mpeg2_qsv"
		#decode_mmal="-c:v ${codec:0:5}_mmal"
		#parameter "--nohw"
		[ "$vcodec" != "" ] && mpeg2=$vcodec
		[ "$hwaccel" == "vaapi" ] && add_vf format=nv12,hwupload && HWACC="$VAAPI" # checkme
		[ "$OUTPUT" == "mpg" ] && mpeg2=copy && deinterlace=
		set_video $mpeg2
		;;
	    "h264")
		#set -x
		video="-c:v:0 copy"
		[ "$vcodec" != "" -a "$vcodec" != "h264" ] && h264=$vcodec
		#[ "$OUTPUT" == "webm" ] && set_vp9
		[ "$OUTPUT" == "mpg" ] && h264=mpeg2
		if [ "$h264_br_g" != "" ]
		then
		    [ "$h264" == "copy" -a $bitr1 -ge $h264_br_g ] && h264=$h264_HD
		    h264_HD=
		fi
		[ "$h264_HD" != "" -a "$h264" == "copy" -a $vw -ge 720 ] && h264=$h264_HD
		[ "$fpso" != "" -a "$h264" == "copy" ] && h264=h264
		decode_cuvid="-c:v:0 h264_cuvid"
		decode_qsv="-c:v:0 h264_qsv"
		#decode_mmal="-c:v h264_mmal"
		decode_mmal="-c:v:0 "$codec"_mmal"
		set_video $h264
		#[ "$OUTPUT" == "webm" ] && set_video vp9
		#exit
		;;
	    "hevc")
		video="-c:v:0 copy"
		deinterlace=
		#[ "$vcodec" != "" ] && hevc=$vcodec
		[ "$vcodec" != "" -a "$vcodec" != "hevc" ] && hevc=$vcodec
		[ "$OUTPUT" == "mpg" ] && hevc=mpeg2
		[ "$OUTPUT" == "webm" ] && hevc=vp9
		decode_cuvid="-c:v:0 hevc_cuvid"
		decode_qsv="-c:v:0 hevc_qsv"
		set_video $hevc
		;;
	    "vvc")
		video="-c:v:0 copy"
		deinterlace=
		vvc=copy
		[ "$vcodec" != "" ] && vvc=$vcodec
		set_video $vvc
		OPT_G="$OPT_G -strict -2"
		#OPT="$OPT -pix_fmt yuv420p"
		;;
	    "vc1")
		video="-c:v:0 copy"
		[ "$OUTPUT" == "vdr" -a "$vc1" == "copy" ] && vc1=h264
		decode_cuvid="-c:v:0 vc1_cuvid"
		decode_mmal="-c:v:0 "$codec"_mmal"
		decode_qsv="-c:v:0 vc1_qsv"
		set_video $vc1
		;;
	    "msmpeg4v3"|"msmpeg4v2"|"mpeg4")
		# [mpeg4 @ 0x7fffeb2a7500] Video uses a non-standard and 
		# wasteful way to store B-frames ('packed B-frames'). 
		# Consider using the mpeg4_unpack_bframes bitstream filter 
		# without encoding but stream copy to fix it.
		[ "$vcodec" != "" -a "$vcodec" != "mpeg4" ] && mpeg4=$vcodec
		#[ "$OUTPUT" == "mp4" ] && echo "mpeg4 in mp4 not allowed" && exit 8
		video="-c:v:0 $mpeg4"
		[ "$OUTPUT" == "vdr" -a "$mpeg4" == "copy" ] && mpeg4=h264
		[ $codec == "mpeg4" ] && decode_cuvid="-c:v:0 mpeg4_cuvid"
		[ "$hwaccel" == "vaapi" ] && add_vf format=nv12,hwupload && HWACC="$VAAPI"
		[ "$hwaccel" == "qsv" ] && add_vf format=nv12,hwupload
		set_video $mpeg4
		;;
	    "vp6f"|"flv1")
		parameter --nohw
		video="-c:v:0 copy"
		set_video copy
		[ "$OUTPUT" == "vdr" ] && set_video h264
		#[ "$OUTPUT" == "webm" ] && set_video vp9
		#[ "$vcodec" != "" ] && set_video $vcodec
		;;
	    "vp8")
		decode_cuvid="-c:v:0 vp8_cuvid"
		decode_qsv="-c:v:0 vp8_qsv"
		video="-c:v:0 copy"
		#[ "$OUTPUT" == "vdr" ] && set_h264
		[ "$OUTPUT" == "vdr" -a "$vp8" == "copy" ] && vp8=h264
		#[ "$vp8" == "h264" ]  && set_h264
		#[ "$vp8" == "hevc" ]  && set_hevc
		set_video $vp8
		;;
	    "vp9")
		decode_cuvid="-c:v:0 vp9_cuvid"
		decode_qsv="-c:v:0 vp9_qsv"
		video="-c:v:0 copy"
		#[ "$OUTPUT" == "vdr" ] && set_h264
		if [ "$OUTPUT" == "vdr" -a "$vp9" == "copy" ]
		then
		     #vp9=hevc
		     vp9=h264
		     [ $vw -ge 720 ] && vp9=hevc
		fi
		#[ "$vp9" == "h264" ]  && set_h264
		#[ "$vp9" == "hevc" ]  && set_hevc
		set_video $vp9
		;;
	    "av1")
		#decode_cuvid="-c:v av1_cuvid"
		decode_qsv="-c:v:0 av1_qsv"
		video="-c:v:0 copy"
		#[ "$OUTPUT" == "vdr" ] && set_h264
		[ "$OUTPUT" == "vdr" -a "$av1" == "copy" ] && av1=h264
		#[ "$av1" == "h264" ]  && set_h264
		#[ "$av1" == "hevc" ]  && set_hevc
		set_video $av1
		;;
	    "wmv3")
		set_h264
		;;
	    "wmapro")
		map="$map -map $str0:$str"
		#audio="$audio -c:$stro $aaclib -b:$stro $aac_6ch_br"
		set_aac
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "ac3"|"truehd")
		#set -x
		[ "$str" == 1 ] && ac3_1=$atyp
		map="$map -map $str0:$str"
		audio_t="-c:$stro copy"
		[ "$acodec" != "" ] && ac3=$acodec
		[ "$OUTPUT" == "webm" ] && ac3=opus
		set_audio $ac3
		[ "$ac3v" != "" -a $bra -eq 192 ] && audio_t="$audio_t -filter:$stro volume=$ac3v"
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		#exit
		;;
	    "eac3")
		map="$map -map 0:$str"
		[ "$OUTPUT" == "mpg" ] && eac3=mp2
		[ "$OUTPUT" == "webm" ] && eac3=opus
		[ "$dpl" == "99" -a "$eac3" == "copy" ] && eac3=eac3
		[ "$dpl" == "$str" -a "$eac3" == "copy" ] && eac3=eac3
		set_audio $eac3
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "dts")
		map="$map -map $str0:$str"
		audio_t="-c:$stro copy"
		[ "$OUTPUT" == "vdr" -a "$dts" == "copy" ] && dts=aac
		[ "$OUTPUT" == "webm" ] && dts=opus
		#echo $line
		#set -x
		IFS='()' read _ _ _ codec_e _ <<< $line
		#echo "[$codec_e]"
		#if [[ "$codec_e" == *DTS-HD* ]]
		#then
		#    OPT="$OPT -bsf:$stro dca_core"
		#fi
		#exit
		set_audio $dts
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "aac")
		map="$map -map $str0:$str"
		audio_t="-c:$stro copy"
		[ "$OUTPUT" == "webm" ] && aac=opus
		[ "$OUTPUT" == "mpg" ] && aac=mp2
		[ "$aac_decode" != "" ] && OPT_I="$OPT_I -c:$str $aac_decode"
		[ "$OUTPUT" == "vdr" -a $ar1 -ne 48000 -a "$aac" == "copy" ] && aac=aac
		set_audio $aac
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "aac_latm")
		map="$map -map 0:$str"
		audio_t="-c:$stro copy"
		[ "$OUTPUT" == "mp4" ] && aac=aac
		[ "$OUTPUT" == "mpg" ] && aac=mp2
		[ "$OUTPUT" == "webm" ] && aac=opus
		set_audio $aac
		[ "$aac_6" != "" -a "$atyp" != "stereo" ] && set_audio $aac_6
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "mp2"|"mp1")
		map="$map -map $str0:$str"
		audio_t="-c:$stro copy"
		[ "$bra" == 128 ] && [ "$mp2_128" != "" ] && mp2=$mp2_128
		[ "$OUTPUT" == "webm" ] && mp2=opus
		[ "$OUTPUT" == "mpg" ] && mp2=copy
		set_audio $mp2
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "mp3")
		#set -x
		map="$map -map $str0:$str"
		[ "$OUTPUT" == "vdr" -a "$mp3" == "copy" ] && mp3=aac
		[ "$OUTPUT" == "webm" ] && mp3=opus
		set_audio $mp3
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		#exit
		;;
	    "pcm_dvd"|"pcm_s16le"|"pcm_s16be"|"pcm_bluray")
		map="$map -map $str0:$str"
		[ "$pcm" == "copy" -a "$codec" == "pcm_dvd" ] && pcm=pcm_s16be
		#[ "$acodec" != "" ] && set_audio $acodec
		#[ "$OUTPUT" == "webm" ] && set_opus
		[ "$OUTPUT" == "webm" ] && pcm=opus
		[ "$acodec" != "" ] && pcm=$acodec
		set_audio $pcm
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "opus")
		map="$map -map $str0:$str"
		[ "$OUTPUT" == "vdr" ] && opus=aac
		set_audio $opus
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		;;
	    "dvb_subtitle")
		map="$map -map $str0:$str"
		# [mp4 @ 0x55c7d71871c0] Could not find tag for codec dvb_subtitle in stream #3, codec not currently supported in container
		if [ "$fmt" == "mp4" ]
		then
		    #subt="$subt -c:$stro dvdsub"
		    OPT_G="$OPT_G -canvas_size:$stro "$hw"x"$vw
		    sencoder=dvdsub
		else
		    #subt="$subt -c:$stro copy"
		    sencoder=copy
		fi
		subt="$subt -c:$stro $sencoder"
		[ "$check" != "" ] && echo $str": $slang $codec -> "$stro": $sencoder" >> "$log_c.2"
		stro1=$(($stro1+1))
		;;
	    "dvd_subtitle")
		map="$map -map $str0:$str"
		if [ "$OUTPUT" == "vdr" ]
		then
		    #subt="$subt -c:$stro dvbsub"
		    sencoder=dvbsub
		else
		    #subt="$subt -c:$stro copy"
		    sencoder=copy
		fi
		subt="$subt -c:$stro $sencoder"
		[ "$check" != "" ] && echo $str": $slang $codec -> "$stro": $sencoder" >> "$log_c.2"
		stro1=$(($stro1+1))
		;;
	    #"subrip"|"ass")
	    "ass")
	    #"dvd_subtitle"|"subrip"|"ass")
	    #"dvd_subtitle"|"ass")
		[ "$OUTPUT" == "vdr" ] && continue
		[ "$OUTPUT" == "webm" ] && continue
		[ "$fmt" == "mp4" ] && continue
		map="$map -map $str0:$str"
		subt="$subt -c:$stro copy"
		stro1=$(($stro1+1))
		;;
	    "subrip")
		[ "$OUTPUT" == "webm" ] && continue
		#[ "$OUTPUT" == "vdr" ] && continue
		if [ "$OUTPUT" == "vdr" ]
		then
		    #OPT="$OPT -filter_complex \"[0:v:0][0:s:$str]overlay[v]\""
		    #map="$map -map 0:$str"
		    hwdownload
		    if [ $str_s > 0 ]
		    then
			add_vf "subtitles=\"$INPUT\":si=$str_s"
		    else
			add_vf "subtitles=\"$INPUT\""
		    fi
		    #add_vf "ass=\"$INPUT\""
		    continue
		fi
		map="$map -map 0:$str"
		subt1="-c:$stro copy"
		[ "$fmt" == "mp4" ] && subt1="-c:$stro mov_text" # checkme
		subt="$subt $subt1"
		stro1=$(($stro1+1))
		;;
	    "hdmv_pgs_subtitle")
		[ "$fmt" == "mp4" ] && continue
		[ "$OUTPUT" == "webm" ] && continue
		map="$map -map $str0:$str"
		if [ "$fmt" == "mp4" ]
		then
		    subt="$subt -c:$stro dvdsub"
		    #subt="$subt -c:$stro mov_text"
		    OPT_G="$OPT_G -canvas_size:$stro "$hw"x"$vw
		elif [ "$OUTPUT" == "vdr" ]
		then
		    subt="$subt -c:$stro dvbsub"
		    OPT_G="$OPT_G -fix_sub_duration"
		    #continue
		else
		    subt="$subt -c:$stro copy"
		fi
		[ "$check" != "" ] && echo $str": $slang $codec -> "$stro": $sencoder" >> "$log_c.2"
		stro1=$(($stro1+1))
		;;
	    #"dvd_nav_packet"|"bin_data"|"png"|"dvb_teletext"|"none"|"mjpeg")
	    "dvd_nav_packet"|"dvb_teletext")
		continue
		;;
	    "mjpeg")
		[ "$OUTPUT" == "vdr" ] && continue
		[ "$mjpeg" == "0" ] && continue
		if [ "$mjpeg" == "dump" ]
		then
		    OPT_G="-dump_attachment:t \"\" $OPT_G"
		    #OPT_G="-dump_attachment:t ./cover.jpg $OPT_G"
		else
		    map="$map -map $str0:$str"
		    subt="$subt -c:$stro copy -disposition:$stro +attached_pic"
		    stro1=$(($stro1+1))
		fi
		;;
	    "bin_data"|"png")
		#set -x
		[ "$OUTPUT" == "vdr" ] && continue
		[ "$fmt" == "mkv" ] && continue
		[ "$fmt" == "webm" ] && continue
		map="$map -map $str0:$str"
		audio_t="-c:$stro copy"
		audio="$audio $audio_t"
		stro1=$(($stro1+1))
		#set +x
		#exit
		;;
	    "text"|"none")
		#set -x
		[ "$typ" != "Attachment:" ] && continue
		if [ "$fmt" == "vdr" ]
		then
		    OPT_G="-dump_attachment:t $dest/info $OPT_G"
		fi
		if [ "$fmt" == "mkv" ]
		then
		    map="$map -map $str0:$str"
		    audio_t="-c:$stro copy"
		    audio="$audio $audio_t"
		    stro1=$(($stro1+1))
		fi
		#exit
		;;
	    *)
		#set -x
		case $typ in
		    "Video:")
			if [ "$fmt" == vdr ]
			then
			    set_video "h264"
			else
			    set_video "copy"
			fi
			;;
		    "Audio:")
			map="$map -map $str0:$str"
			if [ "$fmt" == vdr ]
			then
			    set_audio "aac"
			else
			    set_audio "copy"
			fi
			audio="$audio $audio_t"
			stro1=$(($stro1+1))
			;;
		    "Data:")
			continue
			;;
		    *)
			msg="Codec $codec unknown"
			echo $msg
			echo $msg >> "$log_c"
			exit 8
			;;
		esac
		;;
	esac
	#[ "$check" != "" ] && echo $line
    done < $t
    if [ "$hwaccel" == "vaapi" ]
    then
	[ "$deinterlace" != "" ] && add_vf $deinterlace
    fi
    [ "$vcodec" != "copy" ] && video="$video $vf"
    if [ "$check" != "" ]
    then
	show "$deinterlace"
	show "$OPT"
	show "$OPT_G"
	show "$crop"
	show "$aspect"
	show "$vf"
	cat "$log_c.2"
	rm "$log_c.2"
	echo "==>" $dest
	read answer
	[ "$answer" == "n" ] && exit
	[ "$answer" == "a" ] && auto_conf
    fi
    if [ "$OUTPUT" == "vdr" -a "$sim" == "" ]
    then
	mkdir -p $dest
	mv $log_c $dest/logfile
	log_c=$dest/logfile
    fi
    #[ "$auto" != "1" ] && echo $d $PWD >> $logs
    echo $d $PWD >> $logs
    #exit
}

ctrl_c() {
    #echo "ctrl_c"
    [ "$PID1" != "" ] && kill -15 $PID1
    [ "$PID2" != "" ] && kill -15 $PID2
    sleep 1
    [ -e /proc/$PID1 ] && kill -9 $PID1
    tset
    echo "cancelled"
    exit
}

chk_for_error() {
    log=$1
    chk_msg=$2
    nerror1=$(grep -c "$chk_msg" $log_t)
    echo "$chk_msg $nerror1" >> $log
    nerror=$(($nerror+$nerror1))
}

chk_for_errors() {
    log=$1
    n1=$(grep -n "Output #0" $log)
    [ "$n1" == "" ] && nerror=-1 && return
    IFS=: read n _ <<< $n1
    log_t=/tmp/vt_log_temp
    tail -n +$n $log > $log_t
    nerror=0
    chk_for_error $log "Packet corrupt"
    chk_for_error $log "timestamp discontinuity"
    chk_for_error $log "Missing reference picture"
    rm $log_t
}

transcode() {
    #set -x
    name="$1"
    #[ "$auto" == "1" ] && echo $(<$vtlog) > dest
    #[ "$OUTPUT" == "vdr" ] && echo $(<$vtlog) > dest
    [ "$INPUT" == "vdr" ] && echo $(<$vtlog) > dest
    [ "$OUTPUT" == "vdr" -a "$sim" == "" ] && echo "vdr-transcode@$HOSTNAME" > $dest/.timer
    if [ "$OUTPUT" == "vdr" -a "$vencoder" != "" ]
    then
	OPT="$OPT -metadata service_name=vdr-transcode_$vencoder"
    else
	if [ "${service_name:0:13}" == "vdr-transcode" ]
	then
	    OPT="$OPT -metadata service_name=$service_name"
	else
	    OPT="$OPT -metadata service_name=vdr-transcode"
	fi
    fi
    #exit
    [ "$OUTPUT" == "mp4" ] && OPT="$OPT -metadata comment=vdr-transcode"
    #OPT="$OPT -metadata SOFTWARE=vdr-transcode"
    #opt="-hide_banner $OPT_G $ffmpeg_i -map 0 -c copy $OPT $name.$fmt"
    #opt="-hide_banner $OPT_G $ffmpeg_i -map 0 $video $audio $subt $OPT $name"
    [ -e ffmetadata ] && ffmpeg_i="$ffmpeg_i -i ffmetadata"
    #opt="-hide_banner $OPT_G $HWACC $OPT_I $ffmpeg_i $map $video $audio $subt $OPT $metal \"$name\""
    #[ ${ffmpeg_i:${#ffmpeg_i}-1:1} == \" ] && name="\"$name\""
    [ ${ffmpeg_i: -1} == \" ] && name="\"$name\""
    if [ "$rt_client" == 1 ]
    then
	#set -x
	echo $ffmpeg_i
	ffmpeg_i_s=$ffmpeg_i
	ffmpeg_i=${ffmpeg_i//-i /}
	#ffmpeg_i="-i http://$HOSTNAME:$port/$ffmpeg_i"
	www=/var/www/localhost/htdocs/video
	ln -s $PWD $www
	#ffmpeg_i="-f mpegts -i http://$HOSTNAME/video/$ffmpeg_i"
	ffmpeg_i="-i http://$HOSTNAME/video/$ffmpeg_i"
	#echo $name
	o=$name
	#name=$(basename $name)
	name="-f mpegts -"
	#exit
	#set +x
    fi
    opt="-hide_banner $OPT_G $HWACC $OPT_I $ffmpeg_i $map $video $pass $audio $disp $subt $OPT $metal $name"
    opt1="-hide_banner $OPT_G $HWACC $OPT_I $ffmpeg_i $video -pass 1 -an -f rawvideo -y /dev/null"
    [ "$auto" == "1" ] && opt="-nostdin $opt"
    [ "$pass" != "" ] && echo $ffmpeg $opt1 >> "$log_c"
    echo $ffmpeg $opt >> "$log_c"
    if [ "$sim" != "" ]
    then
	echo $ffmpeg $opt
	exit
    fi
    #exit
    if [ "$rt_client" == 1 ]
    then
	#set -x
	port2=$(($rt_port+1))
	#nc -l $port &
	#PID=$!
	#sleep 5
	#ffprobe -hide_banner $ffmpeg_i
	#nc $rt_server $rt_port -e $ffmpeg $opt
	#$ffmpeg $opt
	#echo $ffmpeg $opt | nc $rt_server $rt_port
	nc -l -p $port2 > $o &
	PID2=$!
	#nc -w 1 $rt_server $rt_port <<< "$ffmpeg $opt | nc $HOSTNAME $(($rt_port+1))"
	#nc -w 1 $rt_server $rt_port 2> $rtlog <<< "$ffmpeg $opt | nc $HOSTNAME $(($rt_port+1))"
	#exec 2> $rtlog
	#nc -w 1 $rt_server $rt_port <<< "$ffmpeg $opt | nc $HOSTNAME $port2" 2> $rtlog
	rtlog=/var/www/localhost/htdocs/files/rt_log
	nc -w 1 $rt_server $rt_port <<< "$ffmpeg $opt 2> $rtlog | nc $HOSTNAME $port2"
	kill -15 $PID2
	#wget http://$HOSTNAME/files/rt_log -O $dest/rt_log
	wget http://$HOSTNAME/files/rt_log
	cat rt_log >> "$log_c"
	rm $www
	#exit
    else
	if [ "$quiet" == 1 ]
	then
	    nice $ffmpeg $opt 2>> "$log_c"
	elif [ "$out_stat" != "" -a "$auto" == "" ]
	then
	    #set -x
	    #[ ${ffmpeg_i:${#ffmpeg_i}-1:1} == \" ] && x=eval
	    [ ${ffmpeg_i: -1} == \" ] && x=eval
	    if [ "$pass" != "" ]
	    then
		echo "pass 1" >> "$log_c"
		$x nice $ffmpeg $opt1 2>&1 | tee -a "$log_c"
		#$x nice $ffmpeg $opt1
		echo "pass 2" >> "$log_c"
	    fi
	    $x nice $ffmpeg $opt 2>> "$log_c" &
	    PID1=$!
	    echo $PID1 > $runvtf
	    #tail -f $log_c &
	    #sleep 1s
	    trap ctrl_c SIGINT
	    #while true; do sleep 2s; clear; status $(<"$vtlog"); done &
	    #while true; do sleep 2s; clear; status "$log_c"; echo "i=inf,l=log"; done &
	    #PID2=$!
	    #msg="s=stat, l=log, q=quiet, h=halt, p=suspend, r=resume"
	    msg="s=stat, l=log, h=help"
	    lastkey=s
	    if [ "$out_stat" == "log" ]
	    then
		lastkey=l
		run_log "$log_c"
	    elif [ "$out_stat" == "d" ]
	    then
		log_d "$log_c"
	    else
		sleep 2
		run_stat "$log_c"
	    fi
	    #wait $PID1
	    while true
	    do
		#sleep 2s
		read -t 2 -n 1 key
		#echo -n $key
		case $key in
		    l)
			run_log "$log_c"
			lastkey=l
			;;
		    w)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			if [ $lastkey == "s" ]
			then
			    run_log "$log_c"
			    lastkey=l
			else
			    run_stat "$log_c"
			    lastkey=s
			fi
			;;
		    d)
			#[ -e /proc/$PID2 ] && kill -15 $PID2
			#log_d "$log_c"
			[ -e /proc/$PID2 ] && kill -15 $PID2
			if [ "$dialog" != "0" ]
			then
			    dialog=0
			    if [ "$lastkey" == "l" ]
			    then
				tail -f "$log_c" &
				PID2=$!
			    fi
			else
			    dialog=1
			    tset=1
			    [ "$lastkey" == "l" ] && log_d "$log_c"
			fi
			[ "$lastkey" == "s" ] && run_stat "$log_c"
			;;
		    h)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			echo "s status, b +bitrate" > $t_stat
			echo "l logfile" >> $t_stat
			echo "w switch logfile <-> status" >> $t_stat
			echo "d switch dialog <-> text" >> $t_stat
			echo "q quiet" >> $t_stat
			echo "t halt" >> $t_stat
			echo "p suspend, r resume" >> $t_stat
			echo "h this page" >> $t_stat
			if [ "$dialog" != "0" ]
			then
			    dialog --begin 4 10 --keep-window --no-shadow \
				--hline "Help" --infobox "$(<$t_stat)" 11 60
			else
			    echo
			    cat $t_stat
			fi
			;;
		    f)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			sleep 1
			less -S "$log_c"
			tail -f "$log_c" &
			PID2=$!
			;;
		    m)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			sleep 1
			mcview "$log_c"
			tail -f "$log_c" &
			PID2=$!
			;;
		    s)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			run_stat "$log_c"
			lastkey=s
			;;
		    b)
			if [ $bitrate -eq 0 ]
			then
			    bitrate=1
			else
			    bitrate=0
			fi
			[ -e /proc/$PID2 ] && kill -15 $PID2
			run_stat "$log_c"
			;;
		    q)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			#clear
			printf "\033c"
			echo "$msg"
			;;
		    t)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			;;
		    p)
			kill -STOP $PID1
			kill -15 $PID2
			echo " resume with r"
			;;
		    r)
			kill -CONT $PID1
			[ -e /proc/$PID2 ] && kill -15 $PID2
			run_log "$log_c"
			;;
		    +)
			renice --relative +5 -p $PID1
			;;
		    -)
			renice --relative -5 -p $PID1
			;;
		    k)
			[ -e /proc/$PID2 ] && kill -15 $PID2
			echo "Abbruch? n/j"
			lastkey=k
			;;
		    n)
			lastkey=
			run_log "$log_c"
			;;
		    j)
			if [ "$lastkey" == "k" ]
			then
			    kill -15 $PID1
			    run_log "$log_c"
			fi
			;;
		esac
		[ ! -e /proc/$PID1 ] && break
	    done
	    [ -e /proc/$PID2 ] && kill -15 $PID2
	    #set +x
	elif [ "$auto" != "" ]
	then
	    [ ${ffmpeg_i: -1} == \" ] && x=eval
	    $x nice $ffmpeg $opt 2>> "$log_c" &
	    PID1=$!
	    echo $PID1 > $runvtf
	    wait $PID1
	else
	    #nice $ffmpeg $opt 2>&1 | tee -a $log_c
	    #sss="nice $ffmpeg $opt"
	    #eval "$sss" 2>&1 | tee -a "$log_c"
	    #[ ${ffmpeg_i:${#ffmpeg_i}-1:1} == \" ] && x=eval
	    [ ${ffmpeg_i: -1} == \" ] && x=eval
	    $x nice $ffmpeg $opt 2>&1 | tee -a "$log_c"
	fi
    fi
    rm -f ffmetadata
    echo "===========================================================" >> "$log_c"
    if [ "$vcodec" != "" ]
    then
	chk_for_errors $log_c
    else
	read _ nerror <<< $(grep ^O info)
    fi
    which mediainfo 2> /dev/null
    [ $? -eq 0 -a "$OUTPUT" == "vdr" ] && mediainfo --Inform="Video;%Format_Profile%" $name >> "$log_c"
    if [[ "$name" == *"("* ]]
    then
	eval $ffprobe -hide_banner -i "\"$name\"" 2>$t	# checkme
    else
	eval $ffprobe -hide_banner -i "$name" 2>$t	# checkme
    fi
    cat $t >> "$log_c"
    #set -x
    line=$(grep "Video:" $t)
    if [ "$line" != "" ]
    then
	fps1=${line%fps*}
	nw=$(echo $fps1|wc -w)
	fpso=$(echo $fps1|cut -d \  -f $nw)
    fi
}

log_conf() {
    if [ -e $1 ]
    then
	echo "====================================" >> "$log_c"
	echo $1 >> "$log_c"
	#cat $1 >> $log_c
	while read line
	do
	    [ "${line:0:1}" != "#" ] && echo $line >> "$log_c"
	done < $1
	echo "====================================" >> "$log_c"
    fi
}

header() {
    read _ _ fuser _ <<< $(ls -l $vtlog)
    [ "$fuser" == "$USER" ] && chmod 666 $vtlog
    d=`$date +"%F %T"`
    v=$($ffmpeg -version)
    v=$(echo $v | cut -d \  -f 3)
    if [ "${v:0:1}" == "N" ]
    then
	ffmpeg_v=5
    else
	ffmpeg_v=$v
    fi
    echo "Start $d vdr-transcode ffmpeg Version $v" > "$log_c"
    sd=$($date +"%F %T" -r $0)
    echo "script date" $sd >> "$log_c"
    [ "$auto" != "" ] && echo "running in background" >> "$log_c"
    #uname -n >> "$log_c"
    #uname -p >> "$log_c"
    echo $(uname -n) $USER >> "$log_c"
    proc=$(uname -p)
    [ "$proc" == "unknown" ] && proc=$(lscpu | grep "Model name:")
    echo $proc >> "$log_c"
    which lspci 2> /dev/null > /dev/null
    if [ $? -eq 0 ]
    then
	vga1=$(lspci | grep VGA)
	echo $vga1 >> "$log_c"
	[[ "$vga1" == *DG2* ]] && vga="DG2"
    fi
    if [ -e /proc/asound/NVidia ]
    then
	xlog=/var/log/Xorg.0.log
	#[ -e $xlog ] && grep "NVIDIA GPU " $xlog >> "$log_c"
	if [ -e $xlog ]
	then
	    grep "NVIDIA GPU " $xlog >> "$log_c"
	    grep "GLX Module" $xlog >> "$log_c"
	fi
    fi
    wsln=/usr/lib/wsl/lib/nvidia-smi
    if [ -e $wsln ]
    then
	echo $($wsln -L | cut -d '(' -f 1) >> "$log_c"
    fi
    log_conf $conf
    log_conf $conf1
    echo -e -n "Parameter:\n" $parameter_log >> "$log_c"
    log_conf $vtc
    echo "PWD:" $PWD >> "$log_c"
    cat $old >> "$log_c"
    [ "$chan_sel_msg" != "" ] && echo $chan_sel_msg >> "$log_c"
    [ "$chan_set_msg" != "" ] && echo $chan_set_msg >> "$log_c"
}

info_create() {
    info=$dest/info
    [ -e $dest/info ] && return
    #cat $t
    dauer1=$(grep "Duration:" $t)
    dauer2=$(echo $dauer1 | cut -d \  -f 2)
    dauer=$($date -u "+%s" -d "1970-01-01 ${dauer2:0:8}")
    sender=vdr-transcode
    if [ "${INPUT:0:4}" == "http" ]
    then
	[[ "$INPUT" == *arteptweb* ]] && sender=Arte
	[[ "$INPUT" == *rodlzdf* ]] && sender=ZDF
	[[ "$INPUT" == *odmdr* ]] && sender=mdr
	[[ "$INPUT" == *cdn-storage.br.de* ]] && sender=br
	[[ "$INPUT" == *wdrmedien* ]] && sender=WDR
	[[ "$INPUT" == *daserste* ]] && sender="Das Erste"
    fi
    echo "C Mediathek $sender" > $info
    echo "E 0 $rec_time $dauer" >> $info
    if [ "$info_subt" != "" ]
    then
	echo "T" $(echo $info_name|tr '_' ' ') >> $info
	echo "S" $(echo $info_subt|tr '_' ' ') >> $info
    else
	[ "$info_name" != "" ] && echo "T" $(echo $info_name|tr '_' ' ') >> $info	# checkme
    fi
    [ "$fpso" == "" ] && fpso=$fps
    echo "F $fpso" >> $info
    echo "P 50" >> $info
    echo "L 99" >> $info
}

to_utf8() {
    f=$(file $1)
    c=$(echo $f|cut -d \  -f 2)
    if [ "$c" == "ISO-8859" ]
    then
        #echo $r
        recode ISO_8859-1...UTF8 $1
    fi
}

copy_vdr() {
    #set -x
    fmt=vdr
    log_c=logfile-temp
    if [ "$ifmt" == "vdr" ]
    then
	#echo $(dirname $PWD)"/"${log_c:3} > $vtlog
	echo $(dirname $PWD)"/"${dest:3}"/logfile" > $vtlog
    else
	echo "$PWD/$log_c" > $vtlog
	[ "$chapt_marks" == "1" -a "$sim" == "" ] && chapt_marks
    fi
    header
    #[ "$auto" != "1" ] && echo $d $PWD >> $logs
    analyze $ffmpeg_i
    if [ "$video_add" != "" ]
    then
	#set -x
	d1=$($ffmpeg -hide_banner $ffmpeg_i 2>&1 | grep "Duration:")
	# Duration: 00:07:53.36, start: 0.000000, bitrate: 948 kb/s
	echo "$d1" >> "$log_c"
	d2=$(echo $d1|cut -d \  -f 2)
	d3=${d2:0:8}
	ds=$($date -u -d "1970-01-01 $d3" "+%s")
	d=$(($ds+$video_add))
	# -i concat:00001.ts
	inp=$(echo $ffmpeg_i|cut -d \  -f 2)
	[ ${inp:0:7} == "concat:" ] && inp=${inp:7}
	ffmpeg_i="-i concat:$inp|$inp"
	OPT_G="$OPT_G -t $d"
	#exit
    fi
    [[ ! "$OPT" == *mpegts_flags* ]] && OPT="$OPT -mpegts_flags system_b"
    #OPT="$OPT -mpegts_flags latm"
    #OPT="$OPT -omit_video_pes_length 0"
    OPT="$OPT -map_chapters -1"
    #OPT="$OPT -metadata creation_time=$(date "+%FT%T" -d @$rec_time)"
    OPT="$OPT $pids"
    [ "$ifmt" == "mp4" -a "$ivcodec" == "hevc" ] && OPT="$OPT -bsf:v hevc_mp4toannexb" # checkme
    transcode $dest/00001.ts
    #if [ -e info ]
    #then
	#cp -p info $dest
    #else
	#if [ "$ifmt" == "dvd" -a -e ../info.vdr ]
	#then
    case $ifmt in
	"vdr")
	    [ -e info ] && cp -p info $dest
	    if [ -e info.vdr ]
	    then
		#cp -p info.vdr $dest/info
		iconv -f ISO-8859-1 -t UTF-8 < info.vdr > $dest/info
		#echo "F 25" >> $dest/info
		echo "L 99" >> $dest/info
		echo "P 50" >> $dest/info
	    fi
	    ;;
	"dvd")
	    #set -x
	    #if [ -e ../info.vdr ]
	    if [ "$info" != "" ]
	    then
		#cp ../info.vdr $dest/info
		cp $info $dest/info
		echo "F 25" >> $dest/info
		echo "L 99" >> $dest/info
		echo "P 50" >> $dest/info
	    else
		info_create
	    fi
	    to_utf8 $dest/info
	    ;;
	"BD")
	    if [ "$BD_info" != "" ]
	    then
		iconv -f ISO-8859-1 -t UTF-8 < $BD_info > $dest/info
	    else
		info_create
	    fi
	    ;;
	*)
	    if [ -e info.vdr ]
	    then
		iconv -f ISO-8859-1 -t UTF-8 < info.vdr > $dest/info
		echo "F 25" >> $dest/info
		echo "L 99" >> $dest/info
		echo "P 50" >> $dest/info
	    else
		info_create
	    fi
	    #[ "$chapt_marks" == "1" ] && chapt_marks $INPUT
	    ;;
    esac
    [ ! -e $dest/info ] && info_create
    #fi
    #[ -e marks ] && cp -p marks $dest
    marks=marks
    [ -e marks.vdr ] && marks=marks.vdr
    if [ -e $marks ]
    then
	echo "======== marks ========" >> $log_c
	cat $marks >> $log_c
	echo "======== marks ========" >> $log_c
    fi
    #vdr=$VDRDIR/vdr
    which vdr 2> /dev/null
    if [ $? -eq 0 ]
    then
	vdr=$(which vdr)
    fi
    if [ -x $VDRDIR/vdr ]
    then
	vdr=$VDRDIR/vdr
    fi
    if [ -x "$vdr" -a "$vcodec" != "vvc" ]
    then
	[ "$auto" == "" ] && echo genindex
        #nice $vdr --genindex="./$dest"
        #set -x
        [ -e $dest/info ] && cp -p $dest/info $dest/info.s
        [[ "$dest" != */* ]] && dest="./"$dest
        nice $vdr --genindex=$dest &
        PID=$!
        wait $PID
        #echo $PID
        grep "\[$PID\]" /var/log/messages | grep "H."
        #set +x
	if [ "$chk_error" == "1" -a "$ifmt" == "vdr" ]
	then
	    cp -p $dest/info $dest/info.s2
	    read _ error_i <<< $(grep ^O $dest/info)
	    [ $nerror -gt $error_i ] && sed -i "s/^O.*/O $nerror/" $dest/info
	    [ $nerror -ne $error_i ] && echo "Errors: vdr $error_i, chk_error $nerror" >> $log_c
	fi
        [ "$fpso" == "" ] && fpso=$fps
        #li=$(ls -l $dest/index|cut -d ' ' -f 5)
        #li=$(stat $dest/index -c "%s")
        li=$(file_size $dest/index)
        fpso=$(grep ^F $dest/info|cut -d \  -f 2)
        [ "$fpso" == "" ] && fpso=25
        #set -x
        #si=$(($li/200*25/$fpso))
        #si=$(($li/8/$fpso))
        sic1=$(($li*100/8/$fpso))
        si=$(($sic1/100))
        sic=$(($sic1-($si*100)))
        #date -u -d @$si +"index %T" >> $log_c
	if [ "$ifmt" != "vdr" -a "$apply_codec" == "1" ]
	then
	    # F 25 720 576 p -
	    read _ _ hw vw type _ <<< $(grep ^F $dest/info)
	    echo $vw$type > info.txt
	fi
    else
	echo $vdr "not found" >> $log_c
    fi
    [ -e messages ] && cp -p messages $dest
    [ -e logfile ] && cp -p logfile $dest/logfile1
    [ -e tscheck ] && cp -p tscheck $dest
    [ -e revision ] && cp -p revision $dest
    if [ -e logfile1 ]
    then
	fd=$($date -r logfile1 "+%Y%m%d%H%M")
        cp -p logfile1 $dest/logfile".$fd"
    fi
    [ -e info.txt ] && cp -p info.txt $dest
    echo "===========================================================" >> $log_c
    if [ "$ifmt" == "vdr" ]
    then
	#[ -e index ] && is1=$(ls -l index|cut -d \  -f 5)
	#[ -e index.vdr ] && is1=$(ls -l index.vdr|cut -d \  -f 5)
	#[ -e index ] && is1=$(stat index -c "%s")
	[ -e index ] && is1=$(file_size index)
	#[ -e index.vdr ] && is1=$(stat index.vdr -c "%s")
	[ -e index.vdr ] && is1=$(file_size index.vdr)
	[ -e info ] && fpsi=$(grep ^F info|cut -d \  -f 2)
	[ "$fpsi" == "" ] && fpsi=25
	#si1=$(($is1/8/$fpsi))
	sic1=$(($is1*100/8/$fpsi))
        si1=$(($sic1/100))
        sic1=$(($sic1-($si1*100)))
	#is2=$(ls -l $dest/index|cut -d \  -f 5)
	#is2=$(stat $dest/index -c "%s")
	is2=$(file_size $dest/index)
	#echo "===========================================================" >> $log_c
	echo -n "index=$is1" >> $log_c
	sic1=$(printf "%02d" $sic1)
	printf " %s " $($date -u -d @$si1 +" %T."$sic1) >> "$log_c"
	if [ -e info ]
	then
	    O=$(grep ^O info)
	    echo "$O" >> "$log_c"
	else
	    echo ""  >> "$log_c"
	fi
    fi
    echo -n "index=$is2" >> $log_c
    sic=$(printf "%02d" $sic)
    [ "$si" != "" ] && printf " %s " $($date -u -d @$si +" %T."$sic) >> "$log_c"
    grep ^O $dest/info >> "$log_c"
    if [ -e $VIDEODIR ]
    then
        /usr/bin/touch $VIDEODIR/.update
    fi
    if [ -e $confs -a "$auto" == "" ]
    then
	while read line
	do
	    [ "$line" == "" ] && continue
	    [ ${line:0:1} == '#' ] && line=${line:1}
	    [ ${PWD:0:${#line}} == $line ] && [ -e $line/.update ] && touch $line/.update
	done < $confs
    fi
    s=$(du $dest)
    newsize=$(echo $s|cut -d \  -f 1)
    if [ "$apply_codec" == "1" ]
    then
	#set -x
	if [ -e info.txt ]
	then
	    i=$(<info.txt)
	    echo "$i $vcodec" > $dest/info.txt
	else
	    echo $vcodec > $dest/info.txt
	fi
	d=`$date +"%F %T"`
	ds=`$date +"%F %T" -d @$start`
	echo $ds $oldsize $ivcodec $O >> $dest/revision
	s=$(du $dest)
	read s _ <<< $s
	O=$(grep ^O $dest/info)
	echo $d $s $vcodec $O >> $dest/revision
    fi
    rm -f $dest/.timer
}

chk_error() { # for already transcoded with older version
    #set -x
    [ ! -e logfile ] && echo "no logfile" && exit
    [ -e info.s2 ] && echo "Already done?" && read answer
    cp -p info info.s2
    #chk_msg="Packet corrupt"
    #nerror=$(grep -c "$chk_msg" logfile)
    #echo "$chk_msg $nerror"
    log=logfile
    chk_for_errors $log
    [ $nerror -eq -1 -a -e logfile.err ] && log=logfile.err && chk_for_errors $log
    [ $nerror -gt -1 ] && tail -n 3 $log
    #sed -i "s/^O.*/O $nerror/" info
    read _ error_i <<< $(grep ^O info)
    if [ "$error_i" == "" ]
    then
	#error_i=0
	echo "O" $nerror >> info
    else
	[ $nerror -gt $error_i ] && sed -i "s/^O.*/O $nerror/" info
    fi
}

copy_file() {
    #set -x
    fmt=$1
    out=$name.$fmt
    [ "$vcodec" != "" ] && out=$name-$vcodec.$fmt # with '-vc' codec in name
    i=1
    while [ -e "$out" ]
    do
	i=$(($i+1))
	out=$name-$i.$fmt
	[ "$vcodec" != "" ] && out=$name-$vcodec-$i.$fmt
    done
    dest=$out
    log_c=$out.log
    echo "$PWD/$log_c" > $vtlog
    header
    analyze $ffmpeg_i
    #OPT="$OPT -timestamp $(date "+%FT%T" -d @$rec_time)"
    #OPT="$OPT -metadata \"creation_time=$(date "+%FT%T" -d @$rec_time)\""
    OPT="$OPT -metadata creation_time=$($date "+%FT%T" -d @$rec_time)"
    #OPT="$OPT -metadata title=\"$(basename $name)\""
    nameb=$(basename "$name")
    #if [[ "$nameb" == *" "* -o "$nameb" == *"("* ]]
    sw=0
    [[ "$nameb" == *" "* ]] && sw=1
    [[ "$nameb" == *"("* ]] && sw=1
    if [ $sw -eq 1 ]
    then
	OPT="$OPT -metadata title=\"$nameb\""
    else
	OPT="$OPT -metadata title=$nameb"
    fi
    [ "$fmt" == "mp4" ] && OPT="$OPT -movflags faststart"
    [ "$ifmt" == "vdr" ] && chapt_marks_mkv
    if [ "$ifmt" == "vdr" -a "$fmt" == "mkv" ]
    then
	info=
	[ -e info ] && info=info
	[ -e info.vdr ] && info=info.vdr
	attach="-attach $info -metadata:s:"$(($stro+1))" mimetype=text/plain"
	[ "$info" != "" ] && map="$map $attach"
    fi
    if [ "$attach_file" != "" ]
    then
	if [ "$fmt" == "mkv" ]
	then
	    ext=${attach_file##*.}
	    case $ext in
		jpg)
		    mime="image/jpeg"
		    ;;
		*)
		    mime="text/plain"
		    ;;
	    esac
	    map="$map -attach $attach_file -metadata:s:$stro1 mimetype=$mime"
	else
	    echo "-attach mkv only"
	    exit 8
	fi
    fi
    transcode "$out"
    #newsize=$(ls -l "$out"|cut -d \  -f 5)
    #newsize=$(stat "$out" -c "%s")
    newsize=$(file_size "$out")
    newsize=$(($newsize/1024))
    #set -x
    [ "$fmt" == "ts" ] && touch -d $($date "+%FT%T" -d @$rec_time) $out
    [ "$dold" == "1" ] && touch -d $($date "+%FT%T" -d @$rec_time) "$out"
    if [ "$ifmt" == "vdr" ]
    then
	info=
	[ -e info ] && info=info
	[ -e info.vdr ] && info=info.vdr
	if [ "$info" != "" ]
	then
	    out=$name.info
	    grep "^T" $info > $out
	    grep "^S" $info >> $out
	    grep "^D" $info >> $out
	fi
    fi
    #set +x
}

copy_audio() {
    #set -x
    fmt=$1
    out=$name.$fmt
    oldsize=1
    i=1
    while [ -e "$out" ]
    do
	i=$(($i+1))
	out=$name-$i.$fmt
    done
    log_c=$out.log
    echo "$PWD/$log_c" > $vtlog
    header
    #analyze $ffmpeg_i
    # Stream #0:1[0x101](deu): Audio: aac (LC) ([15][0][0][0] / 0x000F), 48000 Hz, stereo, fltp, 99 kb/s'
    r=$($x $ffprobe -hide_banner "$ffmpeg_i" 2>&1 | grep "Audio:" | head -n 1)
    typ=$(echo $r | cut -d \  -f 4)
    video="-vn"
    map="-map a:0"
    [ "$select_str" != "" ] && map="-map $str0:$select_str"
    audio="-c copy"
    #[ "$fmt" == "mp3" ] && audio="-c mp3 $mp3_b"
    #[ "$fmt" == "wav" ] && audio=""
    case "$fmt" in
	"mp3")
	    audio="-c mp3 $mp3_b"
	    ;;
	"wav")
	    audio=""
	    ;;
	"aac"|"m4a")
	    if [ "$typ" == "aac" ]
	    then
		audio="-c copy"
	    else
		[ "$acodec" == "aac_v2" ] && mp3_b="-b:a 32k" && opt="-profile:a aac_he_v2"
		audio="-c $aaclib $opt $mp3_b "
	    fi
	    ;;
    esac
    OPT_V=
    transcode "$out"
    #exit
}

copy_aac() {
    #set -x
    fmt=aac
    [ "$1" == "m4a" ] && fmt=m4a
    out=$name.$fmt
    oldsize=1
    i=1
    while [ -e "$out" ]
    do
	i=$(($i+1))
	out=$name-$i.$fmt
    done
    log_c=$out.log
    echo "$PWD/$log_c" > $vtlog
    header
    #set -x
    #analyze $ffmpeg_i
    # Stream #0:1[0x101](deu): Audio: aac (LC) ([15][0][0][0] / 0x000F), 48000 Hz, stereo, fltp, 99 kb/s'
    r=$($x $ffprobe -hide_banner "$ffmpeg_i" 2>&1 | grep "Audio:" | head -n 1)
    typ=$(echo $r | cut -d \  -f 4)
    video="-vn"
    if [ "$typ" == "aac" ]
    then
	audio="-c copy"
    else
	[ "$acodec" == "aac_v2" ] && mp3_b="-b:a 32k" && opt="-profile:a aac_he_v2"
	audio="-c $aaclib $opt $mp3_b "
    fi
    #exit
    map="-map a:0"
    [ "$select_str" != "" ] && map="-map $str0:$select_str"
    OPT_V=
    transcode "$out"
    #exit
}

copy() {
    #set -x
    if [ -e $runvt ]
    then
	oldpid=$(<$runvt)
	if [ -e /proc/$oldpid ]
	then
	    echo "already running"
	    exit 99
	fi
    fi
    echo $$ > $runvt
    stat=$(ps -o stat= -p $$)
    [[ $stat != *+* ]] && auto=1
    #exit
    rm -f $t
    case $OUTPUT in
	"vdr")
	    copy_vdr
	    ;;
	"mkv")
	    copy_file $OUTPUT
	    ;;
	"mp4")
	    copy_file $OUTPUT
	    ;;
	"mpg")
	    copy_file $OUTPUT
	    ;;
	"ts")
	    copy_file $OUTPUT
	    ;;
	"webm")
	    copy_file $OUTPUT
	    ;;
	"asf"|"wmv")	# Advanced Systems Format
	    copy_file $OUTPUT
	    ;;
	"avi")
	    #OPT="$OPT -bsf:v h264_mp4toannexb"
	    copy_file $OUTPUT
	    ;;
	"flv")
	    #OPT="$OPT -strict -1"
	    copy_file $OUTPUT
	    ;;
	"mp3")
	    # copy_mp3 $OUTPUT
	    copy_audio $OUTPUT
	    ;;
	"wav")
	    # copy_wav $OUTPUT
	    copy_audio $OUTPUT
	    ;;
	"aac"|"m4a")
	    #copy_aac $OUTPUT
	    copy_audio $OUTPUT
	    ;;
	#"m4a")
	#    copy_aac $OUTPUT
	#    ;;
	"m2t"|"mka")
	    copy_audio $OUTPUT
	    ;;
	#"jpg")
	#    copy_file $OUTPUT
	#    ;;
	*)
	    echo "-o" $OUTPUT "invalid"
	    exit 8
	    ;;
    esac
}

server() {
    #set -x
    if [ "$1" == "-d" ]
    then
	vdr-transcode --as &
	#server &
	exit
    fi
    if [ -e $runs ]
    then
        oldpid=$(<$runs)
        if [ -e /proc/$oldpid ]
        then
            echo "already running"
            exit 99
        fi
    fi
    #PID=$(pidof $0)
    echo $$ > $runs
    wd=$PWD
    while (true) do
	while read line
	do
	    if [ -e $line ]
	    then
		for rh in $(find $line -name $vtc)
		do
		    dh=$(dirname $rh)
		    if [ ! -e $dh/$vtc ]
		    then
		        continue
		    fi
		    cd $dh
		    if [ ! -e $lck ]
		    then
			touch $lck
			d=`$date +"%F %T"`
			#echo $d $dh >> $logs
			vdr-transcode --auto > vt.log 2> vt.err
			[ -e $line/.update ] && touch $line/.update
		    fi
		    cd $wd
		done
	    fi
	done < $confs
	sleep 60
    done
    rm $runs
    exit
}

server_kill() {
    if [ -e $runs ]
    then
        pid=$(<$runs)
        if [ -e /proc/$pid ]
        then
            kill -15 $pid
            [ $? -gt 0 ] && echo "Error $?"
        else
	    echo "not running"
        fi
    else
	echo "not running"
    fi
    exit
}

auto_queue() {
    #set -x
    n=0
    while read line
    do
	if [ -e $line ]
	then
	    for rh in $(find $line -name $vtc)
	    do
		echo $rh
		n=$(($n+1))
	    done
	fi
    done < $confs
    echo "Anzahl: "$n
    exit
}

ls_del_s() {
    # records marked to delete
    #set -x
    sum=0
    while read line
    do
	if [ -e $line ]
	then
	    for rh in $(find $line -type d -name "*.del")
	    do
		size=$(du $rh)
		size=$(echo $size | cut -d \  -f 1)
		echo $size $rh
		#rmdir $rh
		rm $rh/*
		#rmdir --ignore-fail-on-non-empty $rh
		rmdir $rh
		#exit
		sum=$(($sum+$size))
	    done
	fi
    done < $confs
    echo "Summe="$(($sum/1024))"Mb"
    exit
}

ls_del() {
    # records marked to delete
    #set -x
    t=/tmp/vtc
    t2=/tmp/vtc2
    tac $logs > $t
    sum=0
    i=0
    while read line
    do
	c=$(echo $line | cut -d \  -f 3-)
	ext=${c##*.}
	[ "$ext" != "rec" ] && continue
	c2=${c%.*}".del"
	if [ ! -e "$c2" ]
	then
	    i=$(($i+1))
	    [ $i -gt 100 ] && break
	    continue
	fi
	i=0
	size=$(du $c2)
	size=$(echo $size | cut -d \  -f 1)
	echo $size $c2
	rm $c2/*
	#rmdir --ignore-fail-on-non-empty $c2
	rmdir $c2
	sum=$(($sum+$size))
	#exit
    done < $t
    echo "Summe="$sum $(($sum/1025))"MB"
    exit
}

auto_rdy() {
    # seek .rdy
    #set -x
    sum=0
    while read line
    do
	if [ -e $line ]
	then
	    #for rh in $(find $line -type f -name "*.rdy")
	    find $line -type f -name "*.rdy"
	fi
    done < $confs
    exit
}

auto_play() {
    local loga
    declare -a loga
    
    dialog=0
    noff=1
    t=/tmp/vtc
    t2=/tmp/vtc2
    i=0
    while read line
    do
	#read _ _ d1 _ <<< $line
	d1=$(echo $line|cut -d \  -f 3)
	[ ! -e "$d1" ] && continue
	ext=${d1##*.}
	[ "$ext" != "rec" ] && continue
	[ ! -e $d1/dest ] && continue
	loga[$i]="$line"
	i=$(($i+1))
    done < $logs
    nl=${#loga[*]}
    #exit
    #IFS=$'\n'
    #for line in $file
    for (( i=0; i<$nl; i++ ))
    do
	line=${loga[$i]}
	#echo $line
	#exit
	#read _ _ d1 _ <<< $line
	d1=$(echo $line|cut -d \  -f 3)
	#echo $d1
	#exit
	[ ! -e "$d1" ] && continue
	#set -x
	ext=${d1##*.}
	[ "$ext" != "rec" ] && continue
	[ ! -e $d1/dest ] && continue
	[ ! -e $d1/index ] && continue
	#echo $line
	d2=$(<$d1/dest)
	[ ! -e $d2 ] && continue
	#echo $d2
	#set -x
	a_check $d2
	echo
	echo "p=play"
	read answer
	[ "$answer" == "" ] && continue
	#set -x
	d2=$(dirname $d1)
	d0=$(basename $d1)	# 2018-11-26.20.15.168-0.rec
	n1=$(basename $d2)
	name=${n1//_/' '}
	datum=${d0:8:2}"."${d0:5:2}"."${d0:2:2}" "${d0:11:2}":"${d0:14:2}
	l=$(svdrpsend lstr | grep "$name" | grep "$datum")
	# + l='250-8086 26.11.18 20:15 1:00 nas-2~8TB-2~Serien~Das Boot~S01E01 Neue Wege
	# '50-11719 26.11.18 20:15 1:00* nas-2~8TB-2~Serien~Das Boot~S01E01 Neue Wege
	IFS=$'\r' l2=$(echo $l|tail -n 1)
	unset IFS
	l2=${l2:4}
	#read nr _ <<< $l2
	nr=$(echo $l2|cut -d \  -f 1)
	#echo $nr
	#exit
	svdrpsend play $nr
	read answer
	#exit
    done
    #done < $logs
    exit
}

auto_check_del() {
    local loga
    declare -a loga
    
    dialog=0
    noff=1
    t=/tmp/vtc
    t2=/tmp/vtc2
    i=0
    while read line
    do
	#read _ _ d1 _ <<< $line
	d1=$(echo $line|cut -d \  -f 3)
	[ ! -e "$d1" ] && continue
	ext=${d1##*.}
	[ "$ext" != "rec" ] && continue
	[ ! -e $d1/dest ] && continue
	loga[$i]="$line"
	i=$(($i+1))
    done < $logs
    nl=${#loga[*]}
    #set -x
    #for (( i=0; i<$nl; i++ ))
    nl=$((nl-1))
    for (( i=$nl; i>=0; i-- ))
    do
	line=${loga[$i]}
	#echo $line
	#exit
	d1=$(echo $line|cut -d \  -f 3)
	echo $d1
	#exit
	[ ! -e "$d1" ] && continue
	#set -x
	ext=${d1##*.}
	[ "$ext" != "rec" ] && continue
	[ ! -e $d1/dest ] && continue
	[ ! -e $d1/index ] && continue
	#echo $line
	d2=$(<$d1/dest)
	[ ! -e $d2 ] && continue
	#echo $d2
	#set -x
	tail -n 20 $d2
	echo $d1
	#a_check $d2
	#echo
	read answer
	[ "$answer" == "" ] && continue
	if [ "$answer" == "d" ]
	then
	    echo $d1
	    echo delete
	    #rm $d1/*
	    #rmdir $d1
	    mv $d1 ${d1:0: -3}"del"
	fi
	#set -x
	#read answer
	#exit
    done
    #done < $logs
    exit
}

a_check() {
	    local c2
	    local d1
	    local d2

	    c2="$1"
	    status $c2
	    c2=$(dirname $c2)
	    [ ! -e $c2/logfile ] && return
	    #s=$(ls -l $c/index|cut -d \  -f 5)
	    #echo "index" $s
	    #s=$(ls -l $c2/index|cut -d \  -f 5)
	    #echo "index" $s
	    grep "index=" $c2/logfile
	    #set -x
	    grep "Duration:" $c2/logfile | tail -n 2
	    grep "Duration:" $c2/logfile | tail -n 2 > $t2
	    #  Duration: 01:39:25.94, start: 7539.052489, bitrate: 9692 kb/s
	    #  Duration: 01:39:06.66, start: 1.400000, bitrate: 2013 kb/s
	    d1=$(head -n 1 $t2)
	    d1=$(echo $d1|cut -d \  -f 2)
	    if [ "$d1" != "N/A," ]
	    then
		d1s=$($date -u "+%s" -d "1970-01-01 ${d1:0:8}")
		d1ms=$d1s${d1:9:2}
	    else
		d1ms=0
	    fi
	    d2=$(tail -n 1 $t2)
	    d2=$(echo $d2|cut -d \  -f 2)
	    d2s=$($date -u "+%s" -d "1970-01-01 ${d2:0:8}")
	    d2ms=$d2s${d2:9:2}
	    #echo $d2ms $d1ms
	    echo "Diff" $(($d2ms-$d1ms))"cs"
	    #exit
}

auto_check() {
    #set -x
    dialog=0
    t=/tmp/vtc
    t2=/tmp/vtc2
    tac $logs > $t
    #cat $t
    sum=0
    i=0
    while read line
    do
	c=$(echo $line | cut -d \  -f 3-)
	if [ ! -e "$c" ]
	then
	    i=$(($i+1))
	    [ $i -gt 10 ] && break
	    continue
	fi
	ext=${c##*.}
	if [ "$ext" == "rec" ]
	then
	    [ ! -e $c/dest ] && continue
	    c2=$(<$c/dest)
	    [ ! -e $c2 ] && continue
	    a_check $c2
	    sum=$(($sum+$oldsize))
	fi
    done < $t
    echo "Summe="$sum $(($sum/1025))"MB"
    exit
}

auto_conf() {
    #set -x
    #echo $parameter_log
    #echo $parameter_auto
    touch $vtc
    #IFS=$'\n'
    #IFS='\n'
    IFS='|'
    for p in $parameter_auto
    do
	#p=$(echo $p)
	[ "${p:0:1}" == " " ] && p=${p:1}
	#echo $p
	[ "$p" == "--conf" ] && continue
	[ "$p" == "--p" ] && continue
	echo $p >> $vtc
    done
    cat $vtc
    exit
}

auto_confr() {
    #set -x
    if [ "$min_br" == "" ]
    then
	echo "min_br not set"
	exit
    fi
    for rr in `find . -mount -type d -name "*0.rec"`
    do
	#echo $rr
	[ -e $rr/$vtc ] && continue
	[ -e $rr/$vtc".rdy" ] && continue
	#si=$(stat $rr/index -c "%s")
	si=$(file_size $rr/index)
	fl=$(grep ^F $rr/info)
	read _ f _ <<< $fl
	[ "$f" == "" ] && f=25
	# F 50.02779322
	if [[ "$f" == *.* ]]
	then
	    s=$(echo "$si*25/$f/200"|bc)
	else
	    s=$(($si*25/$f/200))
	fi
	#date -u -d @$s
	w="$rr/*.ts"
	size=0
	for r in $w
	do
	    [ ! -e "$r" ] && continue
	    #s1=$(ls -l --block-size=1k $r|cut -d \  -f 5)
	    #s1=$(stat "$r" -c "%s")
	    s1=$(file_size "$r")
	    size=$(($size+$s1/1024))
	done
	br=$(($size*8/$s))
	if [ $br -gt $min_br ]
	then
	    #set -x
	    echo $br $rr
	    touch $rr/$vtc
	    IFS='|'
	    for p in $parameter_auto
	    do
		#p=$(echo $p)
		[ "${p:0:1}" == " " ] && p=${p:1}
		#echo $p
		IFS=\  read p1 _ <<< "$p"
		[ "$p1" == "--confr" ] && continue
		[ "$p1" == "-confr" ] && continue
		echo $p >> $rr/$vtc
	    done
	    cat $rr/$vtc
	    #exit
	fi
	#exit
    done
    exit
}

auto_confsz() {
    #set -x
    min_size=$1
    [ "${min_size: -1}" == "M" ] && min_size=$((${min_size:0: -1}*1024))
    [ "${min_size: -1}" == "G" ] && min_size=$((${min_size:0: -1}*1024*1024))
    skip=0
    for rr in `find . -mount -type d -name "*0.rec"`
    do
	#echo $rr
	[ -e $rr/$vtc ] && continue
	[ -e $rr/$vtc".rdy" ] && continue
	[ ! -e $rr/index ] && continue
	[ ! -e $rr/info ] && continue
	#si=$(stat $rr/index -c "%s")
	si=$(file_size $rr/index)
	fl=$(grep ^F $rr/info)
	read _ f _ <<< $fl
	[ "$f" == "" ] && f=25
	# F 50.02779322
	if [[ "$f" == *.* ]]
	then
	    s=$(echo "$si*25/$f/200"|bc)
	else
	    s=$(($si*25/$f/200))
	fi
	#date -u -d @$s
	w="$rr/*.ts"
	size=0
	for r in $w
	do
	    [ ! -e "$r" ] && continue
	    #s1=$(ls -l --block-size=1k $r|cut -d \  -f 5)
	    #s1=$(stat "$r" -c "%s")
	    s1=$(file_size "$r")
	    size=$(($size+$s1/1024))
	done
	br=$(($size*8/$s))
	#echo $size $br
	if [ $size -gt $min_size ]
	then
	    #set -x
	    echo $rr
	    #echo $size $br
	    wd="$PWD"
	    cd "$rr"
	    #pwd
	    #oldsize=$size
	    input_vdr
	    #echo $ffmpeg_i
	    inf
	    echo "Press Enter for next, t for touch or parameter"
	    read vtconf
	    if [ "$vtconf" != "" ]
	    then
		if [ "$vtconf" == "t" ]
		then
		    touch vt.conf
		else
		    #read _ _ vtconf2 <<< $vtconf
		    parameter_auto=
		    parameter_line $vtconf
		    IFS='|'
		    for p in $parameter_auto
		    do
			#p=$(echo $p)
			[ "${p:0:1}" == " " ] && p=${p:1}
			#echo $p
			[ "${p:0:7}" == "-confsz" ] && continue
			echo $p >> $vtc
		    done
		    cat $vtc
		    unset IFS
		fi    
	    fi
	    #exit
	    cd "$wd"
	fi
	#exit
    done
    exit
}

auto_sh_conf() {
    # --a_conf
    #set -x
    while read line
    do
	[ "${line:0:1}" != "#" ] && echo $line
    done < $confs
    exit
}

rt_server() {
    #set -x
    if [ -e $runrts ]
    then
	if [ -e /proc/$(cat $runrts) ]
	then
	    echo "Already running"
	    exit
	fi
    fi
    #nc $rt_port -l -e "vdr-transcode -rtse" &
    #nc -p $rt_port -l -e "/bin/bash" 2> $rtlog &
    nc -p $rt_port -l -e "/bin/bash" &
    #nc $rt_port -l &
    echo $! > $runrts
    echo "RT Server startet PID:"$(cat $runrts)
    exit 
}

rt_server_e() {
    set -x
    echo "todo"
    exit
}

rt_server_k() {
    if [ -e $runrts ]
    then
	kill -15 $(cat $runrts)
    fi
    exit
}


#set -x
case "$INPUT" in
    "vdr"|"")
	input_vdr
	;;
    "dvd")
	input_dvd $track
	;;
    "BD")
	#set -x
	input_BD $track
	#exit
	;;
    "chn")
	input_chn $chn $start1
	;;
    "none")
	none=
	;;
    *)
	if [ "${INPUT:0:4}" == "dvd:" ]
	then
	    tr=${INPUT:4}
	    input_dvd $tr
	else
	    input_file
	fi
	;;
esac
set_hwacc

start=$($date +"%s")

#set -x
case $TODO in
    "-h")
	help $2
	;;
    "--streams")
	streams
	;;
    "--inf")
	inf
	exit
	;;
    "--stat")
	dialog=0
	noff=1
	[ -e $vtlog ] && status $(<"$vtlog")
	exit
	;;
    "--astat")
	astat
	exit
	;;
    "--as")
	server
	;;
    "--asd")
	server -d
	;;
    "--ak")
	server_kill
	;;
    "--aq")
	auto_queue
	;;
    "--rmdel"|"--lsdel")
	ls_del
	;;
    "--lsdel_s")
	ls_del_s
	;;
    "--ac")
	dialog=0
	noff=1
	auto_check
	;;
    "--ac_del")
	dialog=0
	noff=1
	auto_check_del
	;;
    "--aplay")
	auto_play
	;;
    "--ardy")
	auto_rdy
	;;
    "--conf")
	auto_conf
	;;
    "--confr"|"-confr")
	auto_confr
	;;
    "-confsz")
	auto_confsz $min_size
	;;
    "--a_conf")
	auto_sh_conf
	;;
    "--diag")
	diag
	;;
    "--rts")
	rt_server
	;;
    "--rtse")
	rt_server_e
	;;
    "--rtsk")
	rt_server_k
	;;
    "-chapt_marks")
	chapt_marks
	exit
	;;
    "--chk_error")
	chk_error
	exit
	;;
    *)
	copy
	;;
esac

[ -e $vtc ] && mv $vtc $vtc.rdy
#set -x
#cp -p "$log_c" $t
cp "$log_c" $t
g=$(id -g -n $USER)
chown $USER:$g $t
# video:85229kB audio:3528kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 4.510196%
# DVD
# [out#0/mpegts @ 0x555aebb91700] video:161954KiB audio:39903KiB subtitle:0KiB other streams:0KiB global headers:0KiB muxing overhead: 13.928559%
r=$(grep "^video:" $t)
if [ "$r" == "" ]
then
    r=$(grep "video:" $t)
    r=${r#*] }
fi
videos=$(echo $r|cut -d \  -f 1)
videos=$(echo $videos|cut -d ':' -f 2)
e=${videos: -2}
#videos=${videos:0:${#videos}-2}
[ "$e" == "kB" ] && videos=${videos:0:-2}
[ "$e" == "iB" ] && videos=${videos:0:-3}
audios=$(echo $r|cut -d \  -f 2)
audios=$(echo $audios|cut -d ':' -f 2)
#audios=${audios:0:${#audios}-2}
[ "$e" == "kB" ] && audios=${audios:0:-2}
[ "$e" == "iB" ] && audios=${audios:0:-3}
dur=$(grep "Duration:" $t|head -n 1)
dur=$(echo $dur|cut -d \  -f 2)
if [ "$dur" != "N/A," ]
then
    durs1=$($date -u "+%s" -d "1970-01-01 ${dur:0:8}")
    brv=$(($videos*8/$durs1))
    bra=$(($audios*8/$durs1))
fi
echo "===========================================================" >> "$log_c"
echo "Video:" $brv"kb/s Audio:" $bra"kb/s" >> "$log_c"
grep "Video:" $t >> "$log_c"
grep "Duration:" $t >> "$log_c"
if [ "$dur" != "N/A," -a "$dur" != "" ]
then
    durs1ms=$durs1${dur:9:2}
    dur=$(grep "Duration:" $t|tail -n 1)
    dur=$(echo $dur|cut -d \  -f 2)
    durs2=$($date -u "+%s" -d "1970-01-01 ${dur:0:8}")
    durs2ms=$durs2${dur:9:2}
    echo "Diff:" $(($durs2ms-$durs1ms))"cs" >> "$log_c"
fi
#[ "$OUTPUT" == "vdr" -a "$si" != "" ] && date -u -d @$si +"index %T" >> "$log_c"
if [ $oldsize -gt 1 ]
then
    #echo "Alt " $oldsize $(show_size $oldsize) >> "$log_c"
    printf "Old  %8d %8s\n" $oldsize $(show_size $oldsize) >> "$log_c"
    prz=$(($newsize*100/$oldsize))
    #echo "Neu " $newsize $(show_size $newsize) $prz"%" >> "$log_c"
    printf "New  %8d %8s %d%%\n" $newsize $(show_size $newsize) $prz >> "$log_c"
    S=$(($oldsize-$newsize))
    #echo "Save" $S $(show_size $S) >> "$log_c"
    printf "Save %8d %8s\n" $S $(show_size $S) >> "$log_c"
fi
if [ "$postproc" != "" -a "$OUTPUT" == "vdr" -a "$ifmt" == "vdr" ]
then
	$postproc $(realpath $dest) $vcodec
fi
ende=$($date +"%s")
sek=$(($ende-$start))
echo -n "Duration " >> "$log_c"
$date -u -d @$sek "+%T" >> "$log_c"
d=`$date +"%F %T"`
echo "End" $d >> "$log_c"
rm -f $lck
rm $runvt
rm $t
rm -f $old
#echo $$ >> "$log_c"
[ "$out_stat" != "" -a "$auto" == "" ] && tail -n 20 "$log_c"
#echo $$
[ "$tset" != "" ] && tset
[ "$auto" == "" ] && echo $dest