#!/bin/sh
#Compress for menat.
#
version=0.9.1-pre5
cmp_version=menat-cmp.sh-$version
LANG=C

user_h=/var/menat
menat_sys_d=/etc/menat
menat_bin=$user_h/bin
menat_mpeg2=$menat_bin/menat-mpeg2.sh
menat_midentify=$menat_bin/menat-midentify
exe_hn=`hostname`
exe_user=`id -un`

. $user_h/bin/menat-functions

n_ident() {

    if [ "$1" = 0 ];then
	dvn=0
	dvn_v=0
    else
	dvn=`expr "$1" + 0 2>/dev/null`;dvn_v=$?
    fi

    if [ $dvn_v = 0 ];then

	ni_v=$1
	while [ ${ni_v:0:1} = 0 ]&&[ ${#ni_v} != 1 ];do
	    ni_v=${ni_v#0}
	    if [ ${#ni_v} = 1 ];then
		break
	    fi
	done

	echo $ni_v
	return 0

    else
	echo ${2:-unknown}
	return $dvn_v
    fi
          }

if [ -w $user_h/localhost/menat/tmp/menat.log ];then
    org_log=$user_h/localhost/menat/tmp/menat.log
else
    org_log=/dev/null
fi

if [ -w $user_h/$exe_hn/menat/tmp/menat.log ];then
    menat_log=$user_h/$exe_hn/menat/tmp/menat.log
else
    menat_log=/dev/null
fi

if [ -f $menat_sys_d/compress.conf ];then

    . $menat_sys_d/compress.conf
    ofps=${cmp_ofps:-29.971}
    acodec=${cmp_acodec:-mp3}

    case "$xvid_qv" in
	[0-6] ) xvid_qv=$xvid_qv ;;
	* ) xvid_qv=0 ;;
    esac

    cmp_wait_span=${cmp_wait_span:-9}
    dvn=`n_ident $cmp_wait_span`;dvn_v=$?
    if [ $dvn_v != 0 ];then
	cmp_wait_span=9
    fi
   
    if [ "$const_dum" ];then

	dvn=`n_ident $cmp_wait_span`;dvn_v=$?
	if [ $dvn_v = 0 ];then
	    const_dum=$dvn
	else
	    const_dum=""
	fi
    fi
fi

if [ -f $menat_sys_d/capture.conf ];then
    ma_ext=`unset ma_ext;. $menat_sys_d/capture.conf;echo $ma_ext`
fi

if [ -f $menat_sys_d/menat.conf ];then
    . $menat_sys_d/menat.conf
    ofps=${cmp_ofps:-29.971}
fi

vcodec=${vcodec:-mpeg4}
vbitrate=${vbitrate:-800}
acodec=${acodec:-mp3}
rm_f=${rm_f:-0}
ofps=${ofps:-29.971}
dum=${dum:-2hour}
ma_ext=${ma_ext:-mjp}
cmp_wait_span=${cmp_wait_span:-9}
dum_rate=${dum_rate:-25}
org_opt="$*"

while [ "$1" ];do

    case $1 in

	"-f" ) #codec
	    shift
	    if [ $1 = wmv2 ];then
		vcodec=wmv2
		cmd_op1=0
	    elif [ $1 = divx ]||[ $1 = mpeg4 ];then
		vcodec=mpeg4
		cmd_op1=z
	    elif [ $1 = xvid ];then
		vcodec=xvid
		cmd_op1=i
	    elif [ $1 = mpeg2 ];then
		vcodec=mpeg2
		cmd_op1=Z
	    elif [ ! "$1" ];then
		echo "$cmp_version: video format is not specified." >&2
		echo "$cmp_version: video format is not specified." >>$menat_log
		exit 1
	    else
		echo "$cmp_version: $1, such format is not suported." >&2
		echo "$cmp_version: $1, such format is not suported." >>$menat_log
		exit 1
	    fi

	    shift
	    ;;
	"-b" ) #vbitrate
	    shift

	    dvn=`n_ident $1`;e_t=$?
	    if [ ! "$1" ];then
		echo "vbitrate is not specified.set to 800kbps" >&2
		vbitrate=800

	    elif [ $e_t != 0 ];then
		echo "$cmp_version: $1 is invalid value for vbitrate." >&2
		echo "$cmp_version: $1 is invalid value for vbitrate." >>$menat_log
		exit 1

	    else
		vbitrate=$1
		dvn=`n_ident $vbitrate`;dvn_v=$?
		if [ $dvn_v != 0 ];then
		    echo "$cmp_version: vbitrate, $1 is not numeric." >&2
		    echo "$cmp_version: vbitrate, $1 is not numeric." >>$menat_log
		    exit 1
		fi
		shift
	    fi
	    ;;

	"-o" ) #out file name
	    shift
	    if [ ${1:0:1} = '-' ];then
		echo "$cmp_version: $1 does not look like valid output file name." >&2
		echo "$cmp_version: $1 does not look like valid output file name." >>$menat_log
		exit 1
	    fi

	    op_fn=${1##*/}
	    shift
	    ;;

	"-F" ) #out fps
	    shift
	    if [ ! "$1" ];then
		echo "ofps is not specified.set to 29.97fps" >&2
		ofps=29.971
	    fi

	    dvn=`n_ident $1`;e_t=$?
	    if [ $e_t != 0 ];then
		echo "$cmp_version: $1 is invalid value for ofps." >&2
		echo "$cmp_version: $1 is invalid value for ofps." >>$menat_log
		exit 1
 
	    elif [ "$1" -gt 60 ];then
		echo "$cmp_version: $1 is too large.set to 4 - 60(fps)." >&2
		echo "$cmp_version: $1 is too large.set to 4 - 60(fps)." >>$menat_log
		exit 1

	    else
		ofps=$1
	    fi
	    shift
	    ;;

	"-r" ) #end process
	    shift
	    rm_f=1
	    ;;

	"-D" ) #for debug
	    shift
	    debug=$1
	    shift
	    ;;

	"-i" ) #cmp_id
	    shift
	    cmp_id=$1
	    shift
	    ;;

	"-a" ) #audio codec
	    shift
	    acodec=$1
	    shift
	    ;;

	"-ab" ) #audio codec
	    shift
	    abitrate=$1
	    shift
	    ;;

	"-s" ) #size
	    shift
	    sp_opt_v=1
	    case $1 in
		1 ) vf="-vf pp=lb,scale=320:240,pp=de/tn";sz_t="320x240";mbd=":mbd=1"
		    cmd_op2=7
		    cmd_op5=0
		    ;;
		2 ) vf="-vf pp=lb,scale=320:240,pp=de,hqdn3d";sz_t="320x240";mbd=":mbd=1"
		    cmd_op2=6
		    cmd_op5=1
		    ;;
		3 ) vf="-vf pp=lb,scale=400:300,pp=de/tn";sz_t="400x300";mbd=":mbd=1"
		    cmd_op2=7
		    cmd_op5=0
		    ;;
		4 ) vf="-vf pp=lb,scale=400:300,pp=de,hqdn3d";sz_t="400x300";mbd=":mbd=1"
		    cmd_op2=6
		    cmd_op5=1
		    ;;
		5 ) vf="-vf pp=lb,scale=480:360,pp=de/tn";sz_t="480x360";mbd=":mbd=1"
		    cmd_op2=7
		    cmd_op5=0
		    ;;
		6 ) vf="-vf pp=lb,scale=480:360,pp=de,hqdn3d";sz_t="480x360";mbd=":mbd=1"
		    cmd_op2=6
		    cmd_op5=1
		    ;;
		7 ) vf="-vf pp=lb,scale=640:480,pp=de/tn";sz_t="640x480";mbd=":mbd=1"
		    cmd_op2=7
		    cmd_op5=0
		    ;;
		8 ) vf="-vf pp=lb,scale=640:480,pp=de,hqdn3d";sz_t="640x480";mbd=":mbd=1"
		    cmd_op2=6
		    cmd_op5=1
		    ;;
		s0 ) vf_sc="-";sz_t="-";sp_opt_v=0 ;;
		s1 ) vf_sc="scale=240:180";sz_t="240x180";sp_opt_v=0 ;;
		s2 ) vf_sc="scale=320:240";sz_t="320x240";sp_opt_v=0 ;;
		s3 ) vf_sc="scale=400:300";sz_t="400x300";sp_opt_v=0 ;;
		s4 ) vf_sc="scale=480:360";sz_t="480x360";sp_opt_v=0 ;;
		s5 ) vf_sc="scale=560:420";sz_t="560x420";sp_opt_v=0 ;;
		s6 ) vf_sc="scale=640:480";sz_t="640x480";sp_opt_v=0 ;;
		* ) sp_opt_v=0 ;;
	    esac
	    cmd_opt_s=$1
	    shift
	    ;;
	"-p" )shift
	    case $1 in
		0 ) pplb="";pp="";mbd="";pptn="";;
		1 ) pplb="";pp="";mbd="";pptn="/tn";;
		2 ) pplb="";pp="";mbd=":mbd=1";pptn="" ;;
		3 ) pplb="";pp="";mbd=":mbd=1";pptn="/tn" ;;
		4 ) pplb="";pp=",pp";mbd="";pptn="" ;;
		5 ) pplb="";pp=",pp";mbd="";pptn="/tn" ;;
		6 ) pplb="";pp=",pp";mbd=":mbd=1";pptn="" ;;
		7 ) pplb="";pp=",pp";mbd=":mbd=1";pptn="/tn" ;;
		8 ) pplb="lb";pp="";mbd="";pptn="" ;;
		9 ) pplb="lb";pp="";mbd="";pptn="/tn" ;;
		a ) pplb="lb";pp="";mbd=":mbd=1";pptn="" ;;
		b ) pplb="lb";pp="";mbd=":mbd=1";pptn="/tn" ;;
		c ) pplb="lb";pp=",pp";mbd="";pptn="" ;;
		d ) pplb="lb";pp=",pp";mbd="";pptn="/tn" ;;
		e ) pplb="lb";pp=",pp";mbd=":mbd=1";pptn="" ;;
		f ) pplb="lb";pp=",pp";mbd=":mbd=1";pptn="/tn" ;;
		* ) pplb="";pp="";mbd="";rm_f="";;
	    esac

	    if [ "$pplb$pp$mbd$pptn" ];then
		cmd_op2=$1
	    else
		cmd_op2=0
	    fi
	    shift
	    ;;

	"-p2" )shift
	    case $1 in
		0 ) lavcdeint="";ppal="";mbd2="";hqdn="" ;;
		1 ) lavcdeint="";ppal="";mbd2="";hqdn="hqdn3d" ;;
		2 ) lavcdeint="";ppal="";mbd2=":mbd=2";hqdn="" ;;
		3 ) lavcdeint="";ppal="";mbd2=":mbd=2";hqdn="hqdn3d" ;;
		4 ) lavcdeint="";ppal="/al";mbd2="";hqdn="" ;;
		5 ) lavcdeint="";ppal="/al";mbd2="";hqdn="hqdn3d" ;;
		6 ) lavcdeint="";ppal="/al";mbd2=":mbd=2";hqdn="" ;;
		7 ) lavcdeint="";ppal="/al";mbd2=":mbd=2";hqdn="hqdn3d" ;;
		8 ) lavcdeint="lavcdeint,";ppal="";mbd2="";hqdn="" ;;
		9 ) lavcdeint="lavcdeint,";ppal="";mbd2="";hqdn="hqdn3d" ;;
		a ) lavcdeint="lavcdeint,";ppal="";mbd2=":mbd=2";hqdn="" ;;
		b ) lavcdeint="lavcdeint,";ppal="";mbd2=":mbd=2";hqdn="hqdn3d" ;;
		c ) lavcdeint="lavcdeint,";ppal="/al";mbd2="";hqdn="" ;;
		d ) lavcdeint="lavcdeint,";ppal="/al";mbd2="";phqdn="hqdn3d" ;;
		e ) lavcdeint="lavcdeint,";ppal="/al";mbd2=":mbd=2";hqdn="" ;;
		f ) lavcdeint="lavcdeint,";ppal="/al";mbd2=":mbd=2";hqdn="hqdn3d" ;;
		* ) lavcdeint="";ppal="";mbd2="";hqdn="";;
	    esac

	    if [ "$lavcdeint$ppal$mbd2$hqdn" ];then
		cmd_op5=$1
	    else
		cmd_op5=0
	    fi
	    shift
	    ;;

	"-e" )shift
	    case $1 in
		0 ) fbdl="";cbp="";obp="";rm_f="";;
		1 ) fbdl="";cbp="";obp="";rm_f="1";;
		2 ) fbdl="";cbp="";obp="1";rm_f="" ;;
		3 ) fbdl="";cbp="";obp="1";rm_f="1" ;;
		4 ) fbdl="";cbp="1";obp="";rm_f="" ;;
		5 ) fbdl="";cbp="1";obp="";rm_f="1" ;;
		6 ) fbdl="";cbp="1";obp="1";rm_f="" ;;
		7 ) fbdl="";cbp="1";obp="1";rm_f="1" ;;
		8 ) fbdl="1";cbp="";obp="";rm_f="" ;;
		9 ) fbdl="1";cbp="";obp="";rm_f="1" ;;
		a ) fbdl="1";cbp="";obp="1";rm_f="" ;;
		b ) fbdl="1";cbp="";obp="1";rm_f="1" ;;
		c ) fbdl="1";cbp="1";obp="";rm_f="" ;;
		d ) fbdl="1";cbp="1";obp="";rm_f="1" ;;
		e ) fbdl="1";cbp="1";obp="1";rm_f="" ;;
		f ) fbdl="1";cbp="1";obp="1";rm_f="1" ;;
		* ) fbdl="";cbp="";obp="";rm_f="";;
	    esac

	    if [ "$fbdl$cbp$obp$rm_f" ];then
		cmd_op6=$((${obp:-0}*4+${rm_f:-0}*8))
		cmd_op6=`printf "%x\n" "${cmd_op6:-0}"`
	    else
		cmd_op6=0
	    fi
	    shift

	    ;;

	"-vs" )shift
	    case "$1" in
		"" ) true ;;
		-F | -f | -o | -p | -p2 | -r | -e ) true ;;
		-b | -s | -i | -D ) true ;;
		* ) vs_hn=$1 ;shift ;;
	    esac
	    ;;

	"-u" )shift
	    opt_ma_user=$1
	    shift
	    ;;

	"-h" )shift
	    hw_cap=1
	    ;;

	* )
	    if [ ! "$1" ];then
		echo "$cmp_version: target is not specified." >&2
		echo "$cmp_version: target is not specified." >>$menat_log
		exit 1

	    elif [ -d "$1" ];then
		echo "$cmp_version: $1 is directory." >&2
		echo "$cmp_version: $1 is directory." >>$menat_log
		exit 1

	    elif [ -f "$1" ];then

		org_f="$1"
		dtt=`du -m $1 2>/dev/null|cut -f1`
		cpu_MHz=`cat /proc/cpuinfo |grep 'cpu MHz'|cut -d':' -f2`
		cpu_MHz=${cpu_MHz:-400}
		cpu_mhz=${cpu_MHz%.*}

		vs_pw=$(($cpu_mhz/100))
		vs_pw_r=$(($cpu_mhz%100))
		if [ $vs_pw_r -gt 50 ];then
		    vs_pw=$(($vs_pw+1))
		fi

		if [ "$debug" = 2 ]&&[ ! "$1" ];then
		    tlong_org=1800
		else
		    mident_org=`$menat_midentify -s $org_f`
		    tlong_org=`echo "$mident_org"|cut -d':' -f7`
		    tlong_org=${tlong_org%s};tlong_org=${tlong_org:-1}
		    rw_size_org=`echo "$mident_org"|cut -d':' -f2`
		    rw_size_org=${rw_size_org%x*}
		    rw_height_org=`echo "$mident_org"|cut -d':' -f2`
		    rw_height_org=${rw_height_org#*x}
		    cap_sol="${rw_size_org}x${rw_height_org}"
		    cap_vbitrate=`echo "$mident_org"|cut -d':' -f4`
		    cap_vbitrate=${cap_vbitrate%kbps};cap_vbitrate=${cap_vbitrate:-0}
		    org_acodec=`echo "$mident_org"|cut -d'=' -f6`
		    org_abitrate=`echo "$mident_org"|cut -d'=' -f8`
		    org_abitrate=${org_abitrate%kbps};org_abitrate=${org_abitrate:-0}
		fi

		cap_vbitrate_k=$(($cap_vbitrate/1024))
		cap_vbitrate_k_r=$(($cap_vbitrate%1024))
		if [ $cap_vbitrate_k_r -ge 512 ];then
		    cap_vbitrate_k=$(($cap_vbitrate_k+1))
		fi

		tlong_m=$(($tlong_org/60))
		tlong_s=$(($tlong_org%60))
		tlong=$tlong_m'm'$tlong_s's'

		if [ $tlong_s != 0 ];then
		    tlong_M=$(($tlong_m+1))
		else
		    tlong_M=$tlong_m
		fi

		dvn=`n_ident $tlong_m`;ev=$?
		if [ $ev != 0 ];then
		    tlong_M=$(($dtt/40))
		fi

		dum_n=$(($(($tlong_M*$dum_rate))/$vs_pw))
		if [ $dum_n -lt 5 ];then
		    dum_n=5
		fi
		dum=${dum_n}minute

		if [ "$debug" = 3 ];then
		    echo dum is $dum.
		    exit 0
		fi

	    else
		echo "$cmp_version: $1, such file or directory is not found." >&2
		echo "$cmp_version: $1, such file or directory is not found." >>$menat_log
		org_b=${1##*/}
		org_bb=${1%.$ma_ext}
		rm -f $menat_h_t/lock.$org_bb
		exit 1
	    fi
	    shift
	    ;;
    esac
done

if [ ${#cmd_opt_s} = 1 ];then
    cmd_opt_s=s$(($(($(($cmd_opt_s-1))%4))+3))
fi

if [ ${#cmd_opt_s} != 1 ];then

    case $vcodec in
	
	wmv2 )
	    case "$cmd_opt_s" in
		s0 ) cmd_op1=0;;
		s1 ) cmd_op1=1;;
		s2 ) cmd_op1=2;;
		s3 ) cmd_op1=3;;
		s4 ) cmd_op1=4;;
		s5 ) cmd_op1=5;;
		s6 ) cmd_op1=6;;
		s7 ) cmd_op1=7;;
		s8 ) cmd_op1=8;;
		* )  cmd_op1=0;;
	    esac
	    ;;

	mpeg4 )
	    case "$cmd_opt_s" in
		s0 ) cmd_op1=z;;
		s1 ) cmd_op1=a;;
		s2 ) cmd_op1=b;;
		s3 ) cmd_op1=c;;
		s4 ) cmd_op1=d;;
		s5 ) cmd_op1=e;;
		s6 ) cmd_op1=f;;
		s7 ) cmd_op1=g;;
		s8 ) cmd_op1=h;;
		* ) cmd_op1=z;;
	    esac
	    ;;
	
	xvid )
	    case "$cmd_opt_s" in
		s0 ) cmd_op1=i;;
		s1 ) cmd_op1=j;;
		s2 ) cmd_op1=k;;
		s3 ) cmd_op1=l;;
		s4 ) cmd_op1=m;;
		s5 ) cmd_op1=n;;
		s6 ) cmd_op1=o;;
		s7 ) cmd_op1=p;;
		s8 ) cmd_op1=q;;
		* ) cmd_op1=i;;
	    esac
	    ;;
	
	mpeg2 )
	    case "$cmd_opt_s" in
		s0 ) cmd_op1=Z;;
		s1 ) cmd_op1=A;;
		s2 ) cmd_op1=B;;
		s3 ) cmd_op1=C;;
		s4 ) cmd_op1=D;;
		s5 ) cmd_op1=E;;
		s6 ) cmd_op1=F;;
		s7 ) cmd_op1=G;;
		s8 ) cmd_op1=H;;
		* ) cmd_op1=Z;;
	    esac
	    ;;
    esac
fi

if [ $vbitrate -le 949 ];then

    cmd_op3=$(($vbitrate/100))
    if [ $(($vbitrate%100)) -gt 50 ];then
	cmd_op3=$(($cmd_op3+1))
    fi

elif [ $vbitrate -le 1200 ];then
    cmd_op3=h
elif [ $vbitrate -le 1600 ];then
    cmd_op3=v
elif [ $vbitrate -le 2400 ];then
    cmd_op3=s
elif [ $vbitrate -le 3600 ];then
    cmd_op3=u
else
    cmd_op3=e
fi

if [ "$sp_opt_v" = 1 ]&&[ "$hw_cap" = 1 ];then

    if [ ${flink_hwc_opt:-0} != 1 ];then 
	vf=`echo "$vf"|sed 's/\/tn//'`
	cmd_op2=6
    else
	vf=${vf%pp=de*}pp=de
	cmd_op2=6
	cmd_op5=0
    fi
fi

obp=${obp:-0}
cbp=${cbp:-0}
cmd_op0=${cmd_op1:-0}${cmd_op2:-0}${cmd_op3:-0}0${cmd_op5:-0}${cmd_op6:-0}

if [ "$org_acodec" = $acodec ];then
    same_acodec=1
else
    same_acodec=0
fi

if [ "$vs_hn" ];then

    for t in `cat $menat_sys_d/vs.list` ;do

	tmp_vs_hn=${t%%.*}
	if [ $tmp_vs_hn = $vs_hn ]&&[ -d $user_h/$t ];then

	    vs_name=$t
	    vs_hn_ok=1
	    break
	fi
    done

    if [ "$vs_hn_ok" != 1 ];then

	if [ -d $user_h/$exe_hn ];then
	    vs_name=$exe_hn
	    vs_hn=${exe_hn%%.*}
	else

	    echo "$cmp_version: vs.list is invalid or bad vs_hn=$vs_hn." >&2
	    echo "$cmp_version: vs.list is invalid or bad vs_hn=$vs_hn." >>$org_log
	    exit 1 
	fi
    fi

else
    if [ -d $user_h/$exe_hn ];then
	vs_name=$exe_hn
	vs_hn=${exe_hn%%.*}
    else
	echo "$cmp_version: vs.list is invalid or bad vs_hn=$vs_hn." >&2
	echo "$cmp_version: vs.list is invalid or bad vs_hn=$vs_hn." >>$org_log
	exit 1 
    fi
fi
vs_h=$user_h/$vs_name
vs_hn=${vs_name%%.*}

menat_h=$vs_h/menat
menat_h_t=$menat_h/tmp
ma_h=$vs_h/vfiles
ma_h_t=$ma_h/tmp

menat_lock=$menat_h_t/lock.menat

if [ -w $menat_h_t/menat.log ];then
    menat_log=$menat_h_t/menat.log
else
    menat_log=/dev/null
fi

ma_cc=$menat_h_t/cc.log

menat_sad=$menat_bin/menat-sad.sh
menat_identify=$menat_bin/menat-midentify
menat_bp=$menat_bin/menat-bp.sh
menat_mail=$menat_bin/menat-mail.sh

cmp_st_YmdaHM=`date '+%Y-%m-%d %a %H:%M'`
st_t=`date '+%Y%m%d%H%M'`;st_tM=`date '+%M'`
st_t_s=`date '+%s'`

if [ ! "$org_f" ];then
    echo "$cmp_version: target is not specified." >&2
    echo "$cmp_version: target is not specified." >>$menat_log
    exit 1
fi

if [ "$org_f" = "$op_fn" ];then
    echo "$cmp_version: original file and output file has the same name." >&2
    echo "$cmp_version: original file and output file has the same name." >>$menat_log
    exit 1
fi

org_b=${org_f##*/}
org_bb=${org_b%.$ma_ext}
cmp_lock_f=$menat_h_t/lock.$org_bb

if [ "$debug" != 1 ];then

    if [ ! -f $cmp_lock_f ];then

	echo tlong_m=$tlong_M >$cmp_lock_f
	echo cap_sol=$cap_sol >>$cmp_lock_f
	echo vbitrate=$cap_vbitrate_k >>$cmp_lock_f
	cap_dd=`$menat_midentify $org_f`
	echo $cap_dd:unknown:$st_t.c.mtq >>$cmp_lock_f
    fi
    cmp_ent_st_t=$st_t
    if [ "${org_f:0:1}" = "/" ];then
	org_f_ap=$org_f
    else
	org_f_ap=$PWD/$org_f
    fi
    echo "org_f_ap=$org_f_ap" >>$cmp_lock_f
    echo "compress entry $st_t" >>$cmp_lock_f
fi

if [ $vcodec = wmv2 ];then
    nw_b=$org_bb.wmv
elif [ $vcodec = mpeg4 ]||[ $vcodec = mpeg2 ]||[ $vcodec = xvid ];then
    nw_b=$org_bb.mpg
else
    echo "$cmp_version: Error occured. vcodec is invalid value." >&2
    echo "$cmp_version: Error occured. vcodec is invalid value." >>$menat_log
    exit 1    
fi

for t in `ls -td $menat_h_t/lock.*` ;do

    if [ -f $t ];then

	if [ $t = $cmp_lock_f ];then
	    continue
	fi

	t_st_t=`grep "^compress entry" $t|tail -n1|cut -d' ' -f3`
	t_st_t=${t_st_t:-0}
	echo "$cmp_version: ent0:$org_b cmp_ent=$cmp_ent_st_t ${t##*/}_st_t=$t_st_t" >>$menat_log
	if [ $t_st_t = 0 ];then
	    echo "$cmp_version: ent0: ${t##*/}_st_t=0" >>$menat_log
	    continue
	elif [ $t_st_t -gt $cmp_ent_st_t ];then
	    echo "$cmp_version: ent0: cmp_ent=$cmp_ent_st_t < ${t##*/}_st_t=$t_st_t" >>$menat_log
	    continue
	elif [ $t_st_t = $cmp_ent_st_t ];then
	    echo "$cmp_version: ent0: cmp_ent=$cmp_ent_st_t = ${t##*/}_st_t=$t_st_t" >>$menat_log
	    for t3 in `ls $cmp_lock_f $t` ;do

		if [ $t3 = $cmp_lock_f ];then
		    cmp_first=1
		else
		    cmp_first=0
		fi
		break
	    done

	    if [ ${cmp_first:-0} = 0 ];then
		echo "$cmp_version: ent0: ${t##*/} is first." >>$menat_log
		continue
	    else
		echo "$cmp_version: ent0: ${cmp_lock_f##*/} is first." >>$menat_log
	    fi
	else
	    echo "$cmp_version: ent0: cmp_ent=$cmp_ent_st_t > ${t##*/}_st_t=$t_st_t" >>$menat_log
	fi

	echo "$cmp_version: ent0: ${t##*/} is added in lock_l." >>$menat_log
	if [ "$lock_l" ];then
	    lock_l="$lock_l $t"
	else
	    lock_l=$t
	fi

    else
	continue 
    fi

done
echo "$cmp_version: s1:$org_b lock_l=\"$lock_l\"" >>$menat_log
if [ -d $menat_h_t/lock.menat ];then

    for t in $menat_h_t/lock.menat/* ;do

	if [ -f $t ];then

	    if [ $t = $menat_h_t/lock.menat/$org_b ];then
		continue
	    fi

	    if [ "$lock_l" ];then
		lock_l="$lock_l $t"
	    else
		lock_l="$t"
	    fi
	fi
    done
fi

echo "$cmp_version: s2:$org_b lock_l=\"$lock_l\"" >>$menat_log
for t in $lock_l ;do

    t_b=${t##*/}
    if [ ${t%/*} = $menat_lock ];then
	t_bb=$t_b
    else
	t_bb=${t#*lock.}
    fi 

    if [ ! "$p_lock_l" ];then
	p_lock_l=$t_b
	pp_lock_l=$t_bb
    else
	p_lock_l="$p_lock_l,$t_b"
	pp_lock_l="$pp_lock_l,$t_bb"
    fi

done
echo "$cmp_version: s2-1:$org_b lock_l=\"$lock_l\"" >>$menat_log
echo "$cmp_version: ss1:$org_b pp_lock_l=\"$pp_lock_l\"" >>$menat_log
nw_f=$ma_h/$nw_b

touch $ma_h_t
if [ "$const_dum" ];then

    dvn=`n_ident $const_dum`;dvn_v=$?
    if [ $dvn_v = 0 ];then
	dum=${const_dum}minute
    fi
fi

if [ "$vcodec" = mpeg4 ];then
    dvcodec=divx5
else
    dvcodec=$vcodec
fi

if [ "$pplb" ];then 
    pp0="pp=lb,"
else
    pp0=""
fi

if [ "$ppal" ]||[ "$pptn" ];then

    if [ "$pp" ];then
	pp_org="$pp"
	pp=",pp=de$ppal$pptn"
    else
	pp=$ppal$pptn
	pp=${pp#/}
	pp=",pp=$pp"
    fi
elif [ "$pp" ];then
    pp_org="$pp"
fi

if [ "$mbd2" ];then
    mbd=$mbd2
fi

if [ "$vcodec" = xvid ];then

    if [ ! "$xvid_qv" ];then

	if [ "$mbd2" ];then
	    xvid_qv=6
	elif [ "$mbd" ];then
	    xvid_qv=4
	else
	    xvid_qv=0
	fi
    fi
else
    xvid_qv=0
fi

#temporaly for wmv8,mbd option caused problems.
if [ "$vcodec" = wmv2 ];then
    mbd=""
fi

if [ "$vf_sc" ];then

    rw_size_cmp=${vf_sc#scale=};rw_size_cmp=${rw_size_cmp%:*}
    if [ "$rw_size_cmp" = "$rw_size_org" ];then
	vf_sc="-"
    fi

    deint=$pp0$lavcdeint
    if [  "$vf_sc" = "-" ];then

	vf_sc=""
	if [ ! "$deint" ];then
	    pp=${pp#,}
	elif [ ! "$pp" ];then
	    deint=${deint%,}

	elif [ ! "$lavcdeint" ];then
	    if [ "$pp_org" ];then
		deint="pp=lb/de$ppal$pptn"
		pp=""
	    else
		deint="pp=lb$ppal$pptn"
		pp=""
	    fi
	fi
    fi

    if [ ! "$vf_sc" ]&&[ ! "$deint" ]&&[ ! "$pp" ]&&[ ! "$hqdn" ];then
	vf=""
    else
	if [ "$deint$vf_sc$pp" ]&&[ "$hqdn" ];then
	    vf="-vf $deint$vf_sc$pp,$hqdn"
	elif [ ! "$hqdn" ];then
	    vf="-vf $deint$vf_sc$pp"
	elif [ ! "$deint$vf_sc$pp" ];then
	    vf="-vf $hqdn"
	fi
    fi

else
    org_sc="scale=$rw_size_org:$rw_height_org"
    sn_v=${vf##*$org_sc*}
    if [ ! "$sn_v" ];then
	vf=${vf#-vf }
	vf_op_ls=`echo $vf|sed 's/,/ /g'`
	i=1;pv=0;vf=""
	for t in $vf_op_ls ;do

	    t_v2=${t##*scale=*}
	    if [ "$t" = pp ];then

		if [ "$pv" = 0 ];then
		    ppv="pp=de"
		    pv=1
		    if [ ! "$vf" ];then
			vf="$ppv"
		    else
			vf="$vf,$ppv"
		    fi
		else
		    vf=`echo $vf|sed "s/$ppv/$ppv\/de/"`
		fi

	    elif [ "${t:0:3}" = "pp=" ];then

		if [ "$pv" = 0 ];then
		    ppv=$t
		    if [ ! "$vf" ];then
			vf="$ppv"
		    else
			vf="$vf,$ppv"
		    fi
		    pv=1
		else
		    pp1=${t#pp=}
		    vf=`echo $vf|sed "s/$ppv/$ppv\/$pp1/"`
		    ppv=$ppv/$pp1
		fi

	    elif [ "$org_sc" != "$t" ];then

		if [ ! "$vf" ];then
		    vf=$t
		else
		    vf="$vf,$t"
		fi
	    fi
	    i=$(($i+1))
	done
	vf="-vf $vf"
    fi
fi

if [ "$debug" = 1 ];then
    echo for debug
    echo "dum: $dum"
    echo "vf: $vf $mbd"
    menat_log=/dev/null
    exit 0
fi

nh=${cmp_st_YmdaHM}
org_f_sz=`du -m $org_f 2>/dev/null|cut -f1`

echo >>$menat_log
echo "$cmp_version: $nw_b, compress started at $nh, $org_b." >>$menat_log
echo "$cmp_version: mident_org=$mident_org dum_n=\$((\$(($tlong_M*$dum_rate))/$vs_pw))" >>$menat_log

if [ "$cmp_id" ]&&[ -f $menat_h_t/$cmp_id ];then
    ma_org=$menat_h_t/$cmp_id
    ma_org_b=$cmp_id
    tmp_ma_org=0

elif [ "$cmp_id" ]&&[ -f $menat_h/$cmp_id ];then
    ma_org=$menat_h/$cmp_id
    ma_org_b=$cmp_id
    tmp_ma_org=0
else

    for tt in `grep -Hc -e ^\#${org_b}: $menat_h_t/*.mtq` `grep -Hc -e ^\#${org_b}: $menat_h/*.mtq` ;do

	if [ `echo $tt|cut -d':' -f2` = 0 ];then
	    continue
	fi

	tt1=`echo $tt|cut -d':' -f1`
	t=${tt1##*/}
	t_12=${t%.*.mtq}
	dvn=`n_ident $t_12`;dvn_v=$? 
	if [ ${#t_12} != 12 ]||[ $dvn_v != 0 ]||[ -d $tt1 ];then
	    continue
	fi

	mqr_ln=`grep -n 'added in que.$' $tt1|tail -n1|cut -d':' -f1`
	if [ ! "$mqr_ln" ];then
	    continue
	fi
 	org_b_ln=`grep -n ^\#${org_b}: $tt1|tail -n1|cut -d':' -f1`

	if [ $mqr_ln -lt $org_b_ln ];then
	    tmp_ma_org=0
	else
	    tmp_ma_org=1
	fi

	ma_org=$tt1
	ma_org_b=$t
	break
    done
    tmp_ma_org=${tmp_ma_org:-2}
fi

if [ -f "$ma_org" ];then

    cap_dev=`$ma_org -c cap_dev`
    case "${cap_dev#/dev/video}" in
	[1-3] ) cap_dev_n=${cap_dev#/dev/video} ;;
	* )  cap_dev_n="" ;;
    esac

    clip_info=`$ma_org -c iepg_title`
    info_comment=`$ma_org -c info_comment`
    info_comment=${info_comment:- }
    if [ "$clip_info" ];then
	info_name="$clip_info"
    else
	info_name="$org_b"
    fi
#############################################################################
    ma_org_12=${ma_org%.*.mtq}
    if [ "$opt_ma_user" ];then
	ma_user=$opt_ma_user
    else
	ma_user=`$ma_org -c menat_user`
    fi
    ma_user=${ma_user:-$exe_user}
    echo "$cmp_version: ma_org found $ma_org for $ma_user." >>$menat_log
    ma_org_id=`$ma_org -c org_id`

    if [ -f $HOME/.menatrc ]||[ -f /home/$ma_user/.menatrc ];then
	
	if [ -f /home/$ma_user/.menatrc ];then
	    ma_rc=/home/$ma_user/.menatrc
	else
	    if [ -f $HOME/.menatrc ]&&[ $ma_user = $exe_user ];then
		ma_rc=$HOME/.menatrc
	    else
		ma_rc=/dev/null
	    fi
	fi
	echo "$cmp_version: found ~/.menatrc for $ma_user." >>$menat_log
	xvid_qv_u=`unset xvid_qv;. $ma_rc;echo $xvid_qv`
	vbitrate_u=`unset vbitrate;. $ma_rc;echo $vbitrate`
	acodec_u=`unset acodec;. $ma_rc;echo $acodec`
	ofps_u=`unset ofps;. $ma_rc;echo $ofps`
    
	if [ "$xvid_qv_u" ];then
	    echo "$cmp_version: xvid_qv was specified to $xvid_qv_u." >>$menat_log
	fi

	if [ "$vbitrate_u" ];then
	    echo "$cmp_version: vbitrate was specified to $vbitrate_u." >>$menat_log
	fi

	if [ "$acodec_u" ];then
	    echo "$cmp_version: acodec was specified to $acodec_u." >>$menat_log
	fi

	if [ "$ofps_u" ];then
	    echo "$cmp_version: ofps was specified to $ofps_u." >>$menat_log
	fi
    fi

    if [ ${cap_dev_n:-0} != 0 ];then
	cdn_ext=/home/$ma_user/.menatrc.$cap_dev_n.$ma_org_12
	cdn_ext_b=.menatrc.$cap_dev_n.$ma_org_12
    else
	cdn_ext=/home/$ma_user/.menatrc.$ma_org_12
	cdn_ext_b=.menatrc.$ma_org_12
    fi

    if [ -f $HOME/$cdn_ext_b ]||[ -f $cdn_ext ];then

	if [ -f $cdn_ext ];then
	    ma_rc2=$cdn_ext
	else
	    if [ -f $HOME/$cdn_ext_b ]&&[ $ma_user = $exe_user ];then
		ma_rc2=$HOME/$cdn_ext_b
	    else
		ma_rc2=/dev/null
	    fi
	fi

	echo "$cmp_version: found ~/.menatrc.$ma_org_12 for $ma_user." >>$menat_log
	xvid_qv_u=`unset xvid_qv;. $ma_rc2;echo $xvid_qv`
	vbitrate_u=`unset vbitrate;. $ma_rc2;echo $vbitrate`
	acodec_u=`unset acodec;. $ma_rc2;echo $acodec`
	ofps_u=`unset ofps;. $ma_rc2;echo $ofps`
    
	if [ "$xvid_qv_u" ];then
	    echo "$cmp_version: xvid_qv was specified to $xvid_qv_u." >>$menat_log
	fi

	if [ "$vbitrate_u" ];then
	    echo "$cmp_version: vbitrate was specified to $vbitrate_u." >>$menat_log
	fi
	
	if [ "$acodec_u" ];then
	    echo "$cmp_version: acodec was specified to $acodec_u." >>$menat_log
	fi

	if [ "$ofps_u" ];then
	    echo "$cmp_version: ofps was specified to $ofps_u." >>$menat_log
	fi
    fi

    xvid_qv=${xvid_qv_u:-$xvid_qv}
    vbitrate=${vbitrate_u:-$vbitrate}
    ofps=${ofps_u:-$ofps}
    acodec=${acodec_u:-$acodec}

    if [ $vcodec = xvid ];then
	mbd="me_quality=$xvid_qv"
    fi

#############################################################################
    k_rg=`$ma_org -c org_id`
    for tt in `grep -Hc -e "^org_id=$k_rg;" $menat_h/*.mtq|grep -v ':0$'` ;do

	tt1=`echo $tt|cut -d':' -f1`
	t=${tt1##*/}
	t_12=${t%.*.mtq}
	nw_sr_id=`$tt1 -c sr_id`
	org_sr_id=`$ma_org -c sr_id`
	dvn=`n_ident $t_12`;dvn_v=$?
	if [ ${#t_12} != 12 ]||[ $dvn_v != 0 ]||[ -d $tt ]||[ "$org_sr_id" = "$nw_sr_id" ];then
	    continue
	fi
	nw_ma_org=$tt1
	nw_ma_org_b=$t
	nw_prs_id=`$nw_ma_org -c prs_id`
	nw_sr_id=`$nw_ma_org -c sr_id`
	break
    done

else

    t=""
    ma_org=$menat_h_t/$st_t.c.mtq
    ma_org_b=$st_t.c.mtq
    cc_v=1

    while [ -f $ma_org ];do
	t=$((${t:-0}+1))
	ma_org=$menat_h_t/$st_t.c$t.mtq
	ma_org_b=$st_t.c$t.mtq
    done

    cap_dev=/dev/video0
    cap_dev_n=""

    if [ "$opt_ma_user" ];then
	ma_user=$opt_ma_user
    else
	ma_user=menat
    fi
    tmp_ma_org=0

    echo "$cmp_version: ma_org was not found for $org_b." >>$menat_log
    echo "$cmp_version: ma_org was set to $ma_org_b for $ma_user." >>$menat_log
    if [ -f $HOME/.menatrc ]||[ -f /home/$ma_user/.menatrc ];then

	if [ -f /home/$ma_user/.menatrc ];then
	    ma_rc=/home/$ma_user/.menatrc
	else
	    if [ -f $HOME/.menatrc ]&&[ $ma_user = menat ];then
		ma_rc=$HOME/.menatrc
	    else
		ma_rc=/dev/null
	    fi
	fi
	echo "$cmp_version: found ~/.menatrc for $ma_user." >>$menat_log
	xvid_qv_u=`unset xvid_qv;. $ma_rc;echo $xvid_qv`
	vbitrate_u=`unset vbitrate;. $ma_rc;echo $vbitrate`
	acodec_u=`unset acodec;. $ma_rc;echo $acodec`
	ofps_u=`unset ofps;. $ma_rc;echo $ofps`
    
	if [ "$xvid_qv_u" ];then
	    echo "$cmp_version: xvid_qv was specified to $xvid_qv_u." >>$menat_log
	fi

	if [ "$vbitrate_u" ];then
	    echo "$cmp_version: vbitrate was specified to $vbitrate_u." >>$menat_log
	fi

	if [ "$acodec_u" ];then
	    echo "$cmp_version: acodec was specified to $acodec_u." >>$menat_log
	fi

	if [ "$ofps_u" ];then
	    echo "$cmp_version: ofps was specified to $ofps_u." >>$menat_log
	fi
    fi

    if [ -f $HOME/.menatrc.tmp ]||[ -f /home/$ma_user/.menatrc.tmp ];then

	if [ -f $HOME/.menatrc.tmp ];then
	    ma_rc2=$HOME/.menatrc.tmp
	else
	    if [ -f /home/$ma_user/.menatrc.tmp ];then
		ma_rc2=/home/$ma_user/.menatrc.tmp
	    else
		ma_rc2=/dev/null
	    fi
	fi
	echo "$cmp_version: found ~/.menatrc.tmp for $ma_user." >>$menat_log
	xvid_qv_u=`unset xvid_qv;. $ma_rc2;echo $xvid_qv`
	vbitrate_u=`unset vbitrate;. $ma_rc2;echo $vbitrate`
	acodec_u=`unset acodec;. $ma_rc2;echo $acodec`
	ofps_u=`unset ofps;. $ma_rc2;echo $ofps`
    
	if [ "$xvid_qv_u" ];then
	    echo "$cmp_version: xvid_qv was specified to $xvid_qv_u." >>$menat_log
	fi

	if [ "$vbitrate_u" ];then
	    echo "$cmp_version: vbitrate was specified to $vbitrate_u." >>$menat_log
	fi
	
	if [ "$acodec_u" ];then
	    echo "$cmp_version: acodec was specified to $acodec_u." >>$menat_log
	fi

	if [ "$ofps_u" ];then
	    echo "$cmp_version: ofps was specified to $ofps_u." >>$menat_log
	fi
    fi

    xvid_qv=${xvid_qv_u:-$xvid_qv}
    vbitrate=${vbitrate_u:-$vbitrate}
    ofps=${ofps_u:-$ofps}
    acodec=${acodec_u:-$acodec}

    org_f_dd=`$menat_midentify $org_f`
    org_vcodec=`echo $org_f_dd|cut -d':' -f3`
    org_acodec=`echo $org_f_dd|cut -d':' -f6`
    org_fps=`echo $org_f_dd|cut -d':' -f5`

    if [ "$rm_f" = 1 ];then
	rm_f_v="-r"
    else
	rm_f_v="cc"
    fi

    if [ $vcodec = xvid ];then
	mbd="me_quality=$xvid_qv"
    fi

    t_ec_M=`echo $tlong|cut -d'm' -f1`
    t_ec_S=`echo $tlong|cut -d'm' -f2`;t_ec_S=${t_ec_S%s}
    tt_ec_S=$((60*$t_ec_M+$t_ec_S))
    t_ec_YmdHM=`date -d "${tt_ec_S}second $nh" '+%Y%m%d%H%M'`
    t_ec_HM=`date -d "${tt_ec_S}second $nh" '+%H:%M'`
    t_ec2_YmdHM=`date '+%Y-%m-%d %H:%M'`
    ma_prs_id=$$
    echo "#!/bin/sh
#created at $nh by $cmp_version.
#$cmp_version: ma_org error occured on $exe_hn.
#$nh - $t_ec_HM ?ch $org_b $ma_org_b

menat_user=$ma_user
menat_host=`hostname -i`
vs_hn=$vs_hn

version=1.1.x.cmp
cmp_version=menat-cr.fake.sh-\$version
exe_cmp_v=1
exe_v=0
LANG=C
org_id=0;prs_id=$ma_prs_id;sr_id=0
week=0
cr_iepg=0
exe_end_ln=
cr_end_ln=

menat_h=$menat_h
menat_h_t=\$menat_h/tmp
ma_h=$ma_h
ma_h_t=\$ma_h/tmp

vcodec=$org_vcodec
acodec=$org_acodec
cap_fps=$org_fps

name_f=$org_f
bfn=$org_b

opt1=$cmd_op0
opt2=""
mopX=\"$org_opt\"
cmp_enc=$vcodec
cmp_v=1
cmp_lv=0
obp=$obp

time_s=$st_t #TIME_START
time_epm=$tlong_M
time_e=$t_ec_YmdHM #TIME_END
p_time_n=\`date '+%Y-%m-%d %a %H:%M'\`
ma_file=$ma_org_b

if [ \"\$1\" = -c ];then

    re_c=\${2:-p_time_n}
    ex_b=\${0%.*.mtq};ex_bb=\${ex_b##*/}
    exm_opt=\${2##*\\(*};exm_opt=\${exm_opt##*\\\`*};exm_opt=\${exm_opt##*\\\$*}
    if [ \"\$2\" ]&&[ ! \"\$exm_opt\" ];then
        echo \"invalid constant \$2.\" >&2
        echo \"\`id -un\` tried to execute invalid constant \$2.\" >>\$menat_h_t/menat.log
        exit 1
    elif [ \"\$ex_bb\" != $st_t ];then
	return 0
    elif [ \"\$re_c\" = iepg_dd ];then
        sed -n \"2,4\"p \$0
        if [ \${3:-0} = 2 ];then
            echo \"#org_id=0:prs_id=$ma_prs_id:sr_id=0; week=0 0; $cmp_version\"
        fi

    elif [ \"\$re_c\" = cap_dd ];then

        if [ \${cr_iepg:-0} = 0 ];then 
            cr_iepg_r=4
        else
            cr_iepg_r=\$cr_iepg
        fi
        dd_start=\$((\$cr_iepg_r+\$cr_end_ln+1))
        dd_end=\$((\$cr_iepg_r+\$cr_end_ln+3))
        sed -n \"\$dd_start,\$dd_end\"p \$0

    elif [ \"\$re_c\" = cmp_dd ];then

        if [ \${cmp_lv:-0} -gt 0 ];then
            sed -n \"\$cmp_lv,\\\$\"p \$0
        fi
    else
        eval out_v='$'\$2
        echo \$out_v 
    fi
    exit 0
fi

exe_tty=\`tty 2>/dev/null\`;tty_v=\$?
exe_user=\`id -un\`
if [ \$tty_v = 0 ];then
    echo >>\$menat_h_t/menat.log
    echo \"\$cmp_version: executed \$ma_file from unexpected tty, \$exe_tty.\" >>\$menat_log
    echo \"\$cmp_version: executed \$ma_file from unexpected tty, \$exe_tty.\"
    exit 1
elif [ \$exe_user != menat ]&&[ \$exe_user != root ];then
    echo >>\$menat_log
    echo \"\$cmp_version: executed \$ma_file by unexpected user, \$exe_user.\" >>\$menat_log
    exit 1
fi

$0 $org_opt

exit 0 #maexe_file_end

#$$ $t_ec2_YmdHM a menat menat_que_record
#$cmp_st_YmdaHM $ma_org_b added in que.
#org_id=0;prs_id=$$;sr_id=0; $cmp_version
#$org_f_dd:$ma_org_b
#options: unknown; ${org_f_sz}MB:$cmd_op0:unknown device:obp=$obp:cap_v=c
#CAPTURE DATA IS UNKNOWN. $ma_org_b menat_ends
" >$ma_org
    chmod 775 -f $ma_org
    ma_ind=`ls -i $org_f|cut -d' ' -f1`
    mf_ind=`ls -i $ma_org|cut -d' ' -f1`
    ma_id="0;$$;0"
    h_addr=`hostname -i`
    ma_id_db=$menat_h_t/ma_id.db
    cmp_lv_tmp=`grep -n ^exit $ma_org`
    cmp_lv_tmp=${cmp_lv_tmp%%:*}
    cmp_lv_tmp=$(($cmp_lv_tmp+1))
    ed -s $ma_org >/dev/null 2>&1 <<EOF
/^exe_end_ln=
s/ln=/ln=$cmp_lv_tmp/
/^cr_end_ln=
s/ln=/ln=$cmp_lv_tmp/
w
q
EOF
    echo "$org_b:$ma_ind:$ma_org_b:$mf_ind:$ma_user:${h_addr% }:$ma_id:${org_f_sz}:?ch" >>$ma_id_db
fi

if [ `grep -c ^${org_b}: $cmp_lock_f` = 0 ];then 
    cap_dd=`$menat_midentify $org_f`
    echo $cap_dd:$ma_org_b >>$cmp_lock_f
fi

rm -f $menat_h_t/*.t.db*

echo "#$cmp_st_YmdaHM, now waiting to compress $org_b." >>$ma_org 
dd_start=`grep -c '^' $ma_org`
u=0
while [ loop ];do

    if [ "$debug" ];then
	break
    fi

    echo >>$menat_log
    ttss=`date -d $dum '+%Y%m%d%H%M'`
    loop_YmdaHM=`date '+%Y-%m-%d %a %H:%M'`
    if [ ! -f $org_f ];then

	echo "$cmp_version: $org_b was removed manually or accidentally." >>$menat_log
	echo "$cmp_version: compression process was aborted at ${loop_YmdaHM}." >>$menat_log
	rm -f $menat_h_t/lock.$org_bb
	exit 0
    fi

    if [ `ps axcu|grep -c "^menat .*mencoder"` != 0 ];then

	echo "$cmp_version: now mencoder is running at ${loop_YmdaHM}." >>$menat_log
	echo "$cmp_version: sleep ${cmp_wait_span:-9}m for waiting to compress $org_b. dum value is $dum." >>$menat_log
	sleep ${cmp_wait_span:-9}m
	continue
    fi

    lock_pv=0
    if [ "$lock_l" ];then

	for t_t in $lock_l ;do

	    if [ ! -f $t_t ]||[ $t_t = $cmp_lock_f ];then
		continue
	    else
		echo "$cmp_version: lock_l is ${p_lock_l:-none}." >>$menat_log
		t_b=${t_t##*/}
		echo "$cmp_version: compress process $org_b was blocked by $t_b at ${loop_YmdaHM}." >>$menat_log
		lock_pv=1	    
		break
	    fi
	done

    elif [ -f $menat_lock/$org_b ];then
	echo "$cmp_version: capture of $org_b was not finished at ${loop_YmdaHM}." >>$menat_log
	lock_pv=1
    fi

    iq=0
    for tt in `ls $menat_h/*.mtq` ;do

	st=${tt##*/}
	st_12=${st%.*.mtq}
	dvn=`n_ident $st_12`;dvn_v=$?;st_v=${st#0} 
	if [ $dvn_v != 0 ]||[ ! -f $tt ]||[ ${#st_12} != 12 ]||[ $st != $st_v ];then
	    continue
	else
	    st_nn=$st
	    if [ $st_12 '>' $ttss ];then
		continue
	    else
		tt_fn=`$tt -c name_f`
		tt_fn_b=${tt_fn##*/}

		fn_vv_l=`echo $pp_lock_l|sed 's/,/ /g'`
		fn_vv=0
		for t1 in $fn_vv_l ;do

		    if [ $t1 = "$tt_fn_b" ];then
			fn_vv=1
			break
		    else
			continue
		    fi
		done

		if [ $fn_vv = 0 ];then

		    if [ ! "$pp_lock_l" ];then
			pp_lock_l="$tt_fn_b"
		    else
			pp_lock_l="$pp_lock_l,$tt_fn_b"
		    fi

		    if [ ! "$dum_lock_l" ];then
			dum_lock_l="$tt_fn_b"
		    else
			dum_lock_l="$dum_lock_l $tt_fn_b"
		    fi

		fi
		iq=1
		echo "$cmp_version: ss1:$u:$org_b pp_lock_l=\"$pp_lock_l\"" >>$menat_log
		echo "$cmp_version: ss1:$u:$org_b dum_lock_l=\"$dum_lock_l\"" >>$menat_log
		break
	    fi
	fi
    done

    if [ $iq = 0 ]&&[ "$lock_pv" != 1 ];then
	echo "$cmp_version: without other jobs and dum ${dum}s expired." >>$menat_log
	echo "$cmp_version: now compress ready for $org_b at ${loop_YmdaHM}." >>$menat_log
	if [ "$lock_l" ];then
	    echo "$cmp_version: lock_l=$lock_l" >>$menat_log
	fi
	break
    fi

    if [ $iq = 1 ];then
	echo "$cmp_version: now ${loop_YmdaHM}. next job $st_nn exists in $dum." >>$menat_log
    fi

    if [ $u = 0 ];then
	echo "$cmp_version: sleep 70s for waiting to compress $org_b." >>$menat_log
	sleep 70s
    else
	echo "$cmp_version: sleep ${cmp_wait_span:-9}m for waiting to compress $org_b." >>$menat_log
	sleep ${cmp_wait_span:-9}m
    fi
    u=$(($u+1))
    touch $cmp_lock_f
done


if [ ! -f $ma_org ];then

    ma_org_12=${ma_org_b:0:12}
    for t in $menat_h_t/$ma_org_12.s$cap_dev_n.mtq ;do

	if [ -f $t ];then
	    ma_org=$t
	    ma_org_b=${t##*/}
	    break
	fi
    done
fi

ed -s $ma_org >/dev/null 2>&1 <<EOF
\$
d
w
q
EOF


rl_st_t=`date '+%Y%m%d%H%M'`
exe_st_YmdaHM=`date '+%Y-%m-%d %a %H:%M'`
rl_st_s=`date '+%s'`

for t0 in `grep ^cap_end_time $cmp_lock_f` ;do

    cap_end_time=${t0%%:*}
    cap_end_time=${cap_end_time#*=}
    cap_r_fn=${t0#*:}
    dum_in_ok=0
    for t in $dum_lock_l ;do

	if [ $t = "$cap_r_fn" ];then
	    dum_in_ok=1
	    break
	else
	    continue
	fi
    done

    if [ $dum_in_ok = 1 ];then
	continue
    fi

    if [ "$lock_l" ];then

	for t in $lock_l ;do
	
	    if [ ${cap_r_fn} = ${t##*/} ];then 
		cap_r_fn_ok=1
		break
	    else
		cap_r_fn_ok=0
	    fi
	done
    else
	cap_r_fn_ok=0
    fi

    if [ ${cap_r_fn_ok:-0} = 0 ];then

	if [ ! "$pp_lock_l" ];then
	    pp_lock_l=$cap_r_fn
	else
	    pp_lock_l="$pp_lock_l,$cap_r_fn"
	fi
	echo "$cmp_version: ss3:$org_b pp_lock_l=\"$pp_lock_l\"" >>$menat_log
    else
	continue
    fi
done
pp_lock_l=${pp1_lock_l:-$pp_lock_l}
echo "$cmp_version: sss:$org_b pp_lock_l=\"$pp_lock_l\"" >>$menat_log

nw_st_dd="$nw_b:$sz_t:$dvcodec:${vbitrate}kbps:$ofps:$acodec:$tlong:$ma_org_b"
cmp_nw_fd=\#"$nw_st_dd"

cmp_flt="${vf#* } ${mbd#:}"
p_cmp_flt="#options: ${cmp_flt:-none}; $cmp_version"

if [ "$debug" = 1 ];then
    echo $nw_st_dd
    echo compress started at $exe_st_YmdaHM, $org_b.
    echo menat_cmp_id $cmp_id $rl_st_t
else 
    echo $nw_st_dd >>$cmp_lock_f
    echo compress started at $exe_st_YmdaHM, $org_b. >>$cmp_lock_f
    echo menat_cmp_id $ma_org_b $rl_st_t >>$cmp_lock_f
fi

if [ "$pp_lock_l" ]&&[ "$pp_lock_l" != "${cmp_lock_f##*/}" ];then
    cmp_nw_dd='#'"compress entry was added in que at $nh for $org_b."
else
    cmp_nw_dd='#'"compress started at $nh, $org_b."
fi

if [ $tmp_ma_org = 0 ];then
    echo "$cmp_nw_dd" >>$ma_org
    echo "$cmp_nw_fd" >>$ma_org
    echo "$p_cmp_flt" >>$ma_org
else
    echo "$cmp_version: tmp_ma_org=$tmp_ma_org, in routin to find $ma_org_b." >>$menat_log
    echo "$cmp_nw_dd" >>$ma_org
    echo "$cmp_nw_fd" >>$ma_org
    echo "$p_cmp_flt" >>$ma_org
fi

if [ "$nw_ma_org" ]&&[ ! -f "$nw_ma_org" ];then

    for t in `ls $menat_h/*.mtq` ;do

	if [ `$t -c org_id` = "$ma_org_id" ]&&[  `$t -c sr_id` = "$nw_sr_id"  ];then 
	    nw_ma_org=$t
	    nw_ma_org_b=${t##*/}
	    break
	fi
    done
fi

if [ -f "$nw_ma_org" ];then

    if [ `grep -c "#$cmp_st_YmdaHM, now waiting to compress $org_b\." $nw_ma_org` != 0 ];then

	wait_st_n=`grep -n "#$cmp_st_YmdaHM, now waiting to compress $org_b\." $nw_ma_org|cut -d':' -f1`
	for t in $wait_st_n ;do

	    ed -s $nw_ma_org >/dev/null 2>&1 <<EOF
$t
d
d
w
q
EOF
	done
    fi

    ed -s $nw_ma_org >/dev/null 2>&1 <<EOF_cmp
\$
?menat_que_record\$
i
$cmp_nw_dd
$cmp_nw_fd
$p_cmp_flt

.
w
q
EOF_cmp

    p_cr_end_ln=`$nw_ma_org -c cr_end_ln`
    if [ "$p_cr_end_ln" ];then

	t_exe_v=`$nw_ma_org -c exe_v`
	r0_cr_end_ln=`wc -l <$nw_ma_org`

	if [ "$t_exe_v" = -2 ];then
	    r_cr_end_ln=$r0_cr_end_ln
	else
	    t_cr_iepg=`$nw_ma_org -c cr_iepg`
	    if [ ${t_cr_iepg:-0} = 0 ];then
		t_cr_iepg=4
	    fi
	    r_cr_end_ln=$(($r0_cr_end_ln-${t_cr_iepg:-0}))
	fi

	ed -s $nw_ma_org >/dev/null 2>&1 <<EOF_cmp3
/^cr_end_ln=
c
cr_end_ln=$r_cr_end_ln
.
w
q
EOF_cmp3
    fi

fi

mop3=`$ma_org -c mop3`;cvbr_ks=${mop3##* }
cvbr_ks=$(($cvbr_ks+112))
time_epm=`$ma_org -c time_epm`

if [ ! "$cvbr_ks" ];then
    cmp_sz=0
else
    cmp_sz=$(($(($cvbr_ks*$time_epm*60))/8192))
fi

or_cmp_sz=$(($cmp_sz+64))
cmp_fmt=`$ma_org -c mop1|cut -d' ' -f2`

if [ ${cmp_fmt:-divx} = xvid ];then
    or_cmp_tM=$(($time_epm*5400/$cpu_mhz))
else
    or_cmp_tM=$(($time_epm*2700/$cpu_mhz))
fi

cmp_bfn=`$ma_org -c cmp_bfn`
if [ ! "$cmp_bfn" ];then

    if [ "$cmp_fmt" = wmv ];then
	cmp_bfn=${bfn%$ma_ext}wmv
    else
	cmp_bfn=${bfn%$ma_ext}mpg
    fi
fi

or_cmp_et=`date -d "${or_cmp_tM}minute" '+%Y%m%d%H%M'`
p_cmp_et=`date -d "${or_cmp_tM}minute" '+%Y-%m-%d %H:%M'`
for t in `ls $menat_h/*.mtq` ;do

    if [ `$t -c time_s` -gt $or_cmp_et ];then
	break
    else
	nx_epm=`$t -c time_epm`
	or_cmp_et=`date -d "${nx_epm}minute $p_cmp_et" '+%Y%m%d%H%M'`
	p_cmp_et=`date -d "${nx_epm}minute $p_cmp_et" '+%Y-%m-%d %H:%M'`
    fi
done

echo or_cmp_et=$or_cmp_et >>$cmp_lock_f
$menat_bp -a $ma_user -N 1 -i $ma_org_b

rm -f $menat_h_t/*.t.db*
##############################################################################################
##############################################################################################
##############################################################################################

if [ $vcodec = xvid ];then

    me_quality=${xvid_qv:-6}
    if [ "$user_opt" ];then

	if [ ${user_acodec:-lavc} = lavc ];then

	    if [ "$abitrate" ];then
		rl_acodec="-oac lavc -lavcopts acodec=$acodec:abitrate=$abitrate"
	    else
		rl_acodec="-oac lavc -lavcopts acodec=$acodec"
	    fi
	else
	    rl_acodec="$user_opt"
	fi

    elif [ "$same_acodec" = 1 ];then
	rl_acodec="-oac copy"
    else
	rl_acodec="-oac lavc -lavcopts acodec=$acodec"
    fi

    echo "$cmp_version: mencoder -info name=\"\\\"$info_name\\\"\":comment=\"\\\"$info_comment\\\"\" \
        -ofps $ofps $vf -ovc xvid $rl_acodec \
	-xvidencopts bitrate=$vbitrate:me_quality=$me_quality \
	-o $ma_h_t/$nw_b $org_f >/dev/null 2>&1" >>$menat_log

    mencoder -info name="\"$info_name\"":comment="\"$info_comment\"" \
	-ofps $ofps $vf -ovc xvid $rl_acodec \
	-xvidencopts bitrate=$vbitrate:me_quality=$me_quality \
	-o $ma_h_t/$nw_b $org_f >/dev/null 2>&1;men_v=$?

elif [ $vcodec = mpeg2 ];then
    echo "$cmp_version: $menat_mpeg2 -a $acodec -b $vbitrate -o $ma_h_t/$nw_b -f ${vf#*-vf } -i $org_f" >>$menat_log
    $menat_mpeg2 -a $acodec -b $vbitrate -o $ma_h_t/$nw_b -f ${vf#*-vf } -i $org_f;men_v=$?
else

    if [ "$user_opt" ];then

	rl_acodec="-oac ${user_acodec:-lavc}"
	if [ ${user_acodec:-lavc} = lavc ];then

	    if [ "$abitrate" ];then
		rl_opt_acodec=":acodec=$acodec:abitrate=$abitrate"
	    else
		rl_opt_acodec=":acodec=$acodec"
	    fi
	else
	    rl_opt_acodec=""
	fi

    elif [ "$same_acodec" = 1 ];then
	rl_acodec="-oac copy"
	rl_opt_acodec=""
    else
	rl_acodec="-oac lavc"
	rl_opt_acodec=":acodec=$acodec"
    fi

    echo "$cmp_version: mencoder -info name=\"\\\"$info_name\\\"\":comment=\"\\\"$info_comment\\\"\" $vf $user_opt \
	-ovc lavc $rl_acodec \
	-lavcopts vcodec=$vcodec$rl_opt_acodec:vbitrate=$vbitrate$mbd \
	-o $ma_h_t/$nw_b $org_f >/dev/null 2>&1;men_v=$?" >>$menat_log

    mencoder -info name="\"$info_name\"":comment="\"$info_comment\"" $vf $user_opt \
	-ovc lavc $rl_acodec \
	-lavcopts vcodec=$vcodec$rl_opt_acodec:vbitrate=$vbitrate$mbd \
	-o $ma_h_t/$nw_b $org_f >/dev/null 2>&1;men_v=$?

fi

##############################################################################################
##############################################################################################
##############################################################################################

ma_ind=`ls -i "$ma_h_t/$nw_b"`;ma_ind=${ma_ind% *}
mf_ind=`ls -i "$ma_org"`;mf_ind=${mf_ind% *}

ma_host=`$ma_org -c menat_host`
ma_org_id=`$ma_org -c org_id`
ma_prs_id=`$ma_org -c prs_id`
ma_sr_id=`$ma_org -c sr_id`
ma_id="$ma_org_id;$ma_prs_id;$ma_sr_id"

if [ $exe_user = root ];then
    chown -f menat.menat $org_f
    chmod -f 664 $org_f
elif [ $exe_user = menat ];then
    chmod -f 664 $org_f
else
    chmod -f 666 $org_f
fi
  
if [ -f $ma_h/$nw_b ];then

    tn=""
    while [ -f $ma_h/tmp$tn-$nw_b ];do
	if [ ! "$tn" ];then
	    tn=1
	else
	    tn=$(($tn+1))
	fi
    done
    mv -f $ma_h_t/$nw_b $ma_h/tmp$tn-$nw_b
    echo "$cmp_version: $nw_b was changed to tmp$tn-$nw_b." >>$menat_log
    nw_b_org=$nw_b
    nw_b="tmp$tn-$nw_b"

else
    mv -f $ma_h_t/$nw_b $ma_h
    nw_b_org=$nw_b
fi

cmp_ed_YmdaHM=`date '+%Y-%m-%d %a %H:%M'`

ma_his_h=$menat_h_t/ma_history
ma_his_ht=$menat_h_t/ma_history.tmp
echo "$nw_b $cmp_ed_YmdaHM compressed for $ma_user" >>$ma_his_h

db_ma_sz=`du -m $ma_h/$nw_b 2>/dev/null|cut -f1`
pch=`$ma_org -c pch`
ma_org_b=${ma_org_b:-unknown}

if [ "$tmp_ma_org" = 1 ];then
    mf_ind=unknown
fi

ma_org_b=${ma_org_b:-unknown}
ma_user=${ma_user:-unknown}
ma_host=${ma_host:-unknown}
pch=${pch:-\?ch}
echo $nw_b:$ma_ind:$ma_org_b:$mf_ind:$ma_user:$ma_host:$ma_id:$db_ma_sz:$pch >>$menat_h_t/ma_id.db
echo "$cmp_version: mv -f $ma_h_t/$nw_b $ma_h" >>$menat_log
echo >>$menat_log

if [ "$men_v" != 0 ];then

    if [ "$rm_f" = 1 ];then
	echo "$cmp_version: compress process failed, $org_b was not removed." >>$menat_log

	rm_f_dd="$org_b was not removed."
	cmp_ed_mesg="compress failed at ${cmp_ed_YmdaHM}, $rm_f_dd"
    else
	echo "$cmp_version: compress process failed." >>$menat_log
	rm_f_dd=""
	cmp_ed_mesg="compress failed at ${cmp_ed_YmdaHM}."
    fi

    echo "$rm_f_dd" >>$cmp_lock_f
    mv -f $cmp_lock_f $menat_h_t/locK.cmp
else
    cmp_dd_MS=`$menat_midentify $ma_h/$nw_b|cut -d':' -f7`
    cmp_tM=`echo $cmp_dd_MS|cut -d'm' -f1`
    cmp_tS=`echo $cmp_dd_MS|cut -d'm' -f2`;cmp_tS=${cmp_tS%s}
    cmp_S=$((60*$cmp_tM+$cmp_tS))

    org_dd_MS=`$menat_midentify $org_f|cut -d':' -f7`
    org_tM=`echo $org_dd_MS|cut -d'm' -f1`
    org_tS=`echo $org_dd_MS|cut -d'm' -f2`;org_tS=${org_tS%s}
    org_S=$((60*$org_tM+$org_tS))

    if [ $cmp_S -lt $(($org_S-60)) ];then
	rm_err=1
    else
	rm_err=0
    fi

    if [ "$rm_f" = 1 ];then

	if [ $rm_err = 1 ];then
	    echo "$cmp_version: UNKNOWN ERROR OCCURED." >>$menat_log
	    echo "$cmp_version: $org_f is *** NOT *** removed." >>$menat_log
	    rm_f_dd="$org_b was not removed."
	    cmp_ed_mesg="unknown error occured at $cmp_ed_YmdaHM, $rm_f_dd"
	else
	    org_b_id1=`ls -i $ma_h/$org_b|cut -d' ' -f1`
	    org_b_id2=`ls -i $org_f|cut -d' ' -f1`
	    if [ -f $ma_h/$org_b ]&&[ "$org_b_id1" = "$org_b_id2" ];then
		db_ok=1
	    else
		db_ok=0
	    fi

	    rm -f $org_f;rm_v=$?
	    if [ $rm_v = 0 ];then

		if [ $db_ok = 1 ];then

		    echo "$cmp_version: $org_b was removed." >>$menat_log
		    rm_f_dd="$org_b was removed."
		
		    grep -v "^$org_b:" $menat_h_t/ma_id.db >$menat_h_t/ma_id.db.tmp
		    mv -f $menat_h_t/ma_id.db.tmp $menat_h_t/ma_id.db
		    chgrp -f menat $menat_h_t/ma_id.*
		    chmod -f 664 $menat_h_t/ma_id.*

		    rm_time=`date '+%Y-%m-%d %a %H:%M'`
		    grep -v "^$org_b " $ma_his_h >$ma_his_ht
		    ma_his_dd=`grep "^$org_b .*created" $ma_his_h|tail -n1`
		    if [ "$ma_his_dd" ];then
			echo "${ma_his_dd% for *}; $rm_time cmp-remove for $ma_user" >>$ma_his_ht
		    else
			echo "$org_b $rm_time cmp-remove for $ma_user" >>$ma_his_ht
		    fi

		    mv -f $ma_his_ht $ma_his_h
		    chgrp -f menat $ma_his_h
		    chmod -f 664 $ma_his_h
		    if [ -f $ma_his_ht ];then
			chgrp -f menat $ma_his_ht
			chmod -f 664 $ma_his_ht
		    fi

		    h_c=`wc -l <$ma_his_h`
		    hist_mx=${hist_mx:-2048}
		    remove=remove
		    p_dc_ln=$((${h_c:-0}-$hist_mx))
		    i=0

		    while [ ${p_dc_ln:-0} -gt 0 ];do

			dc=`grep -n "$remove" $ma_his_h|head -n1`
			dc_c=`grep -c ' removed ' $ma_his_h`
			if [ ! "$dc" ];then
			    break
			elif [ ${dc_c:-1} -lt 2 ];then
			    remove="cmp-remove"
			    continue
			else
			    dc_ln=${dc%%:*}
			    sed -n "${dc_ln}p" $ma_his_h >>$ma_his_h.back
			    ed -s $ma_his_h >/dev/null 2>&1 <<EOF
${dc_ln}d
w
q
EOF
			    h_c=`wc -l <$ma_his_h`
			fi

			i=$(($i+1))
			if [ $i -gt ${p_dc_ln:-0} ];then
			    break
			fi
		    done

		else
		    echo "$cmp_version: $org_b was removed out of db." >>$menat_log
		    echo "$cmp_version: [ -f $ma_h/$org_b ]&&[ \"$org_b_id1\" = \"$org_b_id2\"">>$menat_log
		fi

	    else
		echo "$cmp_version: remove of $org_b was failed." >>$menat_log
		rm_f_dd="remove of $org_b was failed."
	    fi
	    cmp_ed_mesg="compress ended at $cmp_ed_YmdaHM, $rm_f_dd"
	fi

    else

	if [ $rm_err = 0 ];then
	    cmp_ed_mesg="compress ended at ${cmp_ed_YmdaHM}."
	else
	    cmp_ed_mesg="unknown error occured at ${cmp_ed_YmdaHM}."
	fi
    fi
    
fi
echo "$cmp_version: $nw_b, $cmp_ed_mesg" >>$menat_log
echo "$nw_b, $cmp_ed_mesg" >>$cmp_lock_f

chmod -f 664 $ma_h/$nw_b
if [ "$nw_b" != "$op_fn" ]&&[ "$op_fn" ];then
    mv -f $ma_h/$nw_b $ma_h/$op_fn
    echo "$cmp_version: $nw_b was moved to $op_fn." >>$menat_log
fi

################################
####### pr_tl_tM start #########
################################
ed_t_s=`date '+%s'`
cc_t=`date '+%Y-%m-%d %a %H:%M'`

cap_t_ls=`grep ^cap_time= $cmp_lock_f`
cmp_t_s=$ed_t_s

if [ "$cap_t_ls" ];then

    for t in $cap_t_ls ;do

	cap_t=`echo ${t%%:*}|cut -d'=' -f2`
	cmp_t_s=$(($cmp_t_s-$cap_t))

	cap_t_m=$(($cap_t/60))
	if [ $(($cap_t%60)) -ge 30 ];then
	    cap_t_m=$(($cap_t_m+1))
	fi

	if [ $cap_t_m = 1 ]||[ $cap_t_m = 0 ];then
	    cap_t_m=1
	    minute=minute
	else
	    minute=minutes
	fi

	cap_fn=`echo $t|cut -d':' -f2`
	if [ "$p_cap_dd" ];then
	    p_cap_dd="$p_cap_dd
#compress was suspended to capture $cap_fn for $cap_t_m$minute."
	else
	    p_cap_dd="#compress was suspended to capture $cap_fn for $cap_t_m$minute."  
	fi
    done
fi

pr_s=$(($cmp_t_s-$rl_st_s))
pr_tl_tM=$(($pr_s/60))
pr_tl_tM_r=$(($pr_s%60))
if [ $pr_tl_tM_r -ge 30 ];then
    pr_tl_tM=$(($pr_tl_tM+1))
fi

if [ $pr_tl_tM = 0 ];then
    pr_tl_tM=1
fi

################################
#######  pr_tl_tM  end #########
################################

pt_tH=$(($pr_tl_tM/60))

if [ "$pt_tH" = 0 ];then
    p_pt_tHM=${pr_tl_tM}ʬ
else
    yt_tM=$(($pr_tl_tM%60))
    p_pt_tH=${pt_tH}»þ´Ö;pt_tM=${yt_tM}ʬ
    p_pt_tHM=$p_pt_tH$pt_tM
fi

tlong_org_100=$tlong_org'00'
cmp_sp=$(($tlong_org_100/$pr_s))
if [ "$pr_tl_tM" = 0 ];then
    p_cmp_sp="unknown"
    
elif  [ ${#cmp_sp} = 1 ];then
    p_cmp_sp=x0.0$cmp_sp	

elif  [ ${#cmp_sp} = 2 ];then
    p_cmp_sp=x0.$cmp_sp	
    
else
    cmp_sp_N=${cmp_sp%??};cmp_sp_fp=${cmp_sp#$cmp_sp_N}	
    p_cmp_sp=x$cmp_sp_N.$cmp_sp_fp
fi

cmp_f_sz=`du -m $ma_h/$nw_b 2>/dev/null|cut -f1`
p_f_sz=$cmp_f_sz'MB'

org_f_sz_100=$org_f_sz'00'
if [ "$cmp_f_sz" != 0 ];then
    cmp_r=$(($org_f_sz_100/$cmp_f_sz))
else
    cmp_r=0
fi

if [ "$cmp_r" = 0 ];then
    p_cmp_r="unknown"

elif  [ ${#cmp_r} = 1 ];then
    p_cmp_r=x0.0$cmp_r	

elif  [ ${#cmp_r} = 2 ];then
    p_cmp_r=x0.$cmp_r
    
else
    cmp_r_N=${cmp_r%??};cmp_r_fp=${cmp_r#$cmp_r_N}	
    p_cmp_r=x$cmp_r_N.$cmp_r_fp
fi

ed_t_YmdaHM=`date '+%Y-%m-%d %a %H:%M'`

if [ "$pp_lock_l" ];then
    cmp_his="#compress started at $exe_st_YmdaHM after waiting for $pp_lock_l."
    if [ "$p_cap_dd" ];then
	cmp_his="$cmp_his
$p_cap_dd"
    fi
else
    if [ "$p_cap_dd" ];then
	cmp_his="$p_cap_dd"
    fi
fi

if [ "$cmp_his" ];then
    nw_f_dd="$cmp_his
#`$menat_identify $ma_h/$nw_b`:$ma_org_b"
else
    nw_f_dd="#`$menat_identify $ma_h/$nw_b`:$ma_org_b" 
fi

m0=`df -Pm $ma_h|tail -n1|tr -s ' ' ' '|cut -d' ' -f4`
m1=`du -msL $ma_h 2>/dev/null`
m1=${m1%$ma_h};m1=$(($m1))
ma_h_mm="$m1/$(($m0+$m1))(MB)"

f_obp=`grep ^obp= $ma_org|head -n1|cut -d';' -f1|cut -d'=' -f2`
if [ "$obp" = 1 ]||[ "$f_obp" = 1 ];then
	
    if [ -x "$menat_bp" ];then
	
	$menat_bp -a $ma_user -i ${ma_org_b:-$st_t.Em.mtq} $ma_h/$nw_b;bp_v=$?
	if [ "$bp_v" = 0 ];then
	    echo "$cmp_version: backup was completed." >>$menat_log
	else
	    echo "$cmp_version: backup was faild." >>$menat_log
	fi
    fi
    p2_cmp_flt="${p_cmp_flt}
#men_v=$men_v; bp_v=$bp_v; $p_f_sz $p_pt_tHM ${p_cmp_sp}ÇÜ® °µ½ÌΨ $p_cmp_r; $ma_h_mm"

else
    $menat_bp -N 0
    p2_cmp_flt="${p_cmp_flt}
#men_v=$men_v; $p_f_sz $p_pt_tHM ${p_cmp_sp}ÇÜ® °µ½ÌΨ $p_cmp_r; $ma_h_mm"
fi

nw_e_dd="#$cmp_ed_mesg"

ma_org_12=${ma_org_b%.*.mtq}
t_mx=0

if [ 'dirname $ma_org' = $menat_h ]&&[ ! -f "$ma_org" ];then

    if [ -f $menat_h_t/$ma_org_12.s$cap_dev_n.mtq ];then
	ma_org=$menat_h_t/$ma_org_12.s$cap_dev_n.mtq

    elif [ -f $menat_h_t/$ma_org_12.f$cap_dev_n.mtq ];then
	ma_org=$menat_h_t/$ma_org_12.f$cap_dev_n.mtq

    elif [ -f $menat_h_t/$ma_org_12.E$cap_dev_n.mtq ];then
	ma_org=$menat_h_t/$ma_org_12.E$cap_dev_n.mtq
    fi
fi



if [ "$ma_prs_id" ];then

    nw_prs_ls1=`grep -Hc "^org_id=$ma_org_id;" $menat_h/*.mtq|grep -v ':0$'`
    nw_prs_ls2=`grep -Hc "^org_id=$ma_org_id;" $menat_h_t/*.mtq|grep -v ':0$'`

    for t in $nw_prs_ls1 $nw_prs_ls2 ;do

	t_f=${t%%:*}

	t_mx=`grep -n "^#$nw_b_org:" $t_f|tail -n1`
	t_mx=${t_mx%%:*}
	if [ ! "$t_mx" ];then
	    t_mx=0
	    continue
	fi

	if [ `grep -c "^#compress ended .* $org_b .*" $t_f` != 0 ];then
	    continue
	fi

	if [ ${cc_v:-0} = 1 ]&&[ $ma_prs_id != `$t_f -c prs_id` ];then
	    continue
	fi

	ed -s $t_f >/dev/null 2>&1 <<EOF_cmp2
$t_mx
c
$nw_f_dd
.
+
c
$p2_cmp_flt
.
a
$nw_e_dd
.
w
q
EOF_cmp2

	if [ ${cc_v:-0} = 1 ];then

	    ed -s $t_f >/dev/null 2>&1 <<EOF_cmp3
/^exe_v=
c
exe_v=$men_v
.
w
q
EOF_cmp3

	fi

	if [ ${ma_prs_id:-0} = "`$t_f -c prs_id`" ];then

	    if [ "`$t_f -c cmp_lv`" ];then
		ed -s $t_f >/dev/null 2>&1<<EOF
/^cmp_lv=
c
cmp_lv=$dd_start
.
w
q
EOF
	    fi

	    if [ ! -f $ma_cc ];then
		echo "cc.log was created at $cc_t by `id -un` in $cmp_version" >>$ma_cc
		chmod -f 664 $ma_cc
		chgrp -f menat $ma_cc
	    fi
	    cc_dd=`sed -n "$(($t_mx-1)),\\\$p" $t_f`
	    ed -s $ma_cc >/dev/null 2>&1 <<EOF_cc
1
a

$cc_dd
.
w
q
EOF_cc

	else
	    p_cr_end_ln=`$t_f -c cr_end_ln`
	    if [ "$p_cr_end_ln" ];then

		t_cr_v=`$t_f -c exe_v`
		if [ "$t_cr_v" = -2 ];then
		    r_cr_end_ln=$p_cr_end_ln
		else
		    r_cr_end_ln=`grep -n ' menat_que_record$' $t_f|cut -d':' -f1`
		    r_cr_end_ln=$(($r_cr_end_ln-1))
		fi

		ed -s $t_f >/dev/null 2>&1 <<EOF_cmp3
/^cr_end_ln=
c
cr_end_ln=$r_cr_end_ln
.
w
q
EOF_cmp3
	    fi
	fi
    done
fi

opt_i_ma=${ma_org_b:-$st_t.Em.mtq}
to_addr=${ma_user:-menat}
if [ "$rm_err" = 1 ];then
    cmp_m_v=2
elif [ "$men_v" = 0 ];then
    cmp_m_v=0
else
    cmp_m_v=1
fi

echo "$cmp_version: menat-mail.sh -a $to_addr -v $cmp_m_v -p 1 -i $opt_i_ma -n $nw_b" >>$menat_log
$menat_mail -a $to_addr -v $cmp_m_v -p 1 -i $opt_i_ma -n $nw_b -vs $vs_hn;mail_v=$?

if [ $mail_v = 0 ];then
    echo "$cmp_version: mail sent to $ma_user." >>$menat_log
else
    echo "$cmp_version: failed to send mail to $ma_user." >>$menat_log
fi

if [ -f $cmp_lock_f ];then
    mv -f $cmp_lock_f $menat_h_t/locK.cmp
fi

rm -f $menat_h_t/*.t.db*

$menat_sad $cmp_version &

exit 0
# 2005-05-10 Tue 22:03  for 0.8.3-pre1 hw_cap was implemented.
# 2005-05-05 Thu 12:27  for 0.8.2-rc1 cmp time exactness was revised.
# 2005-05-01 Sun 13:37  for 0.8.1-pre1 data format was changed.
# 2005-04-29 Fri 20:15  for 0.7.17-pre1 .menatrc was implemented.
# 2005-04-17 Sun 16:04  for 0.7.14-pre1 xvid was implemented.
# 2005-04-10 Sun 19:27  for 0.7.13-rc1 cc.log order was changed.
# 2005-04-03 Sun 04:41  for 0.7.12 error message was revised.
# 2005-03-24 Thu 07:08  for 0.7.7 cc.log was implemented.
# 2005-03-23 Wed 19:20  for 0.7.4 nice execution and rm org_f routine was revised.
# 2005-03-23 Wed 02:12  for 0.7.0 mpeg2 was implemented.
# 2005-03-09 Wed 02:12  for 0.6.1 interchangeble bug in dum was fixed.
# 2005-03-07 Mon 09:52  for 0.5.7 obp bug was fixed.
# 2005-03-01 Tue 07:00  for 0.5.2a new blunch started for mtq extension.
# 2005-02-24 Thu 07:00  for 0.4.8-pre7 ma_h renewal routine for vs.cgi was implemented.
# 2005-02-23 Wed 20:15  for 0.4.8-pre4 menat-bp option -a was added.
# 2005-02-20 Sun 23:17  for 0.4.7-pre2 search filename was changed from ed implemented to grep.
# 2005-02-20 Sun 19:00  for 0.4.6 division by 0 error which occures in compress failed bug was fixed.
# 2005-02-16 Wed 01:46  for 0.4.6-pre1,filename safty bug was fixed.
# 2005-02-11 Fri 15:16  for 0.4.5c,many bugs were fixed.
# 2005-02-09 Wed 19:00  for 0.4.4,mp3 sysconf bug was fixed and pr_tl_tM rutine was revised.
# 2005-01-29 Sat 21:49  for 0.4.1,many bugs were fixed.
# 2005-01-28 Fri 16:20  for 0.4.0,ma_id.db format was revised.
# 2005-01-21 Fri 23:00  for 0.3.5,info mail was implemented.
# 2005-01-19 Wed 02:40  for 0.3.1a,scale filter verboseness was reducted.
# 2005-01-15 Sat 13:52  for 0.3.0c,back up process was implemented.
# 2005-01-05 Wed 16:09  for 0.2.8a,filename safty was revised and ma_histroy was implemented.
# 2005-01-02 Sun 22:23  for 0.2.7a,nadesico was followed.
# 2004-12-18 Sat 02:46  for 0.2.6,the bug that tn was ignored was fixed.
# for 0.2.5b,-p2 option was added.
# for 0.2.4d,filename safty was added.
# for 0.2.2d,date format was revised.
# for 0.2.2c,time calculation process and compress lock was revised.
# for 0.2.0a,log process was revised.
# for 0.1.4a,option mbd=1 is added.
# for 0.1.3,if mencoder failed,-r are not to be executed.