#!/bin/bash

#	OtrCut - ein Script, um die Cutlists von	#
# http://www.cutlist.de, http://cutlist.mbod.net	#
#	 oder http://cutlist.at			#
#	auch unter Linux/Unix nutzen zu können		#
#							#
#		Weitere Infosn unter:			#
#		http://www.siggimania4u.de		#
#							#

#Hier werden die Variablen definiert
ver=20080909		#Version yyyymmdd
COUNT=0		#Zähler
Start=Start	
Duration=Duration
local=no	#Nach Lokaler Cutlist suchen?
error=no	#Bei Fehlern abbrechen?
continue=0	#Wenn keine Cutlist gefunden wurde, weitermachen
input=""	#Input-File
vorhanden=no	#Lokale Cutlist gefunden?
avidemux=no	#Avidemux verwenden?
cutlist=no	#Auswahl mehrere Cutlist anzeigen?
verbose=no	#Ausführliche ausgabe?
tmp="/tmp/otrcut"	#TMP-Verzeichnis
cutlist_local=""	#Lokaler Cutlistname
overwrite=no		#Existierende DAteien überschreiben?
aviprog=""
output="cut"	#Ausgabe Verzeichnis
bewertung="no"    #Bewertung abgeben?
debug="no"	#Sollen die Ausgeben von Avidemux angezeigt werden?
play="no"
nachher="no"
lingui="no"
warn="yes"
server="0"
user="otrcut"	#Hier bitte einen Benutzernamen mit mindestens 3 Zeichen setzen
toprated=no
error_found=0
cutlist_with_error_name=no

#Hier wird der Player festgelegt, der mit der Option -p gestartet werden soll.
#Z.B.: vlc, xine, mplayer, kaffeine, ...
player="vlc"

rot="\033[22;31m"	#Rote und fette Schrift
end="\033[0m"	#Aufhebung der Farbgebung

#Hier ist die Hilfe
function help ()
{
cat <<HELP
OtrCut-Version: $ver
Dieses Script schneidet OTR-Filme anhand der Cutlists von http://cutlist.de, http://cutlist.mbod.net oder http://cutlist.at.
Es können entweder die Tools avisplit und avimerge oder avidemux gewählt werden.
Avidemux kann im Gegensatz zu avisplit auch zwischen Keyframes schneiden.
Hier die Anwendung:

otrcut.sh [optionen] -i film.mpg.avi
Nur bewerten: otrcut.sh -nb -i film.mpg.avi
Avideumx & Bewertung: otrcut.sh -a -b -i "*.avi"
Avisplit & Bewertung: otrcut.sh -b -i "*.avi"

Optionen:

-i, --input [arg]	Input Datei/Dateien

-a, --avidemux		Avidemux statt Avisplit/Avimerge verwenden

-c, --cutlist		Falls mehrere Cutlist für den Film auf dem Server liegen, wir immer die erste gewählt. Funktioniert nihct zusammen mit -t, --toprated

-e, --error		Bei nicht gefundener Cutlist das Programm beenden

-t, --tmp [arg]		TMP-Ordner angeben, Standart "/tmp/otrcut"

-l, --local [arg]	Lokale Cutlist für angegebenen Film benutzen

-o, --output [arg]	Ausgabeort wählen, Standart "./cut"

-ow, --overwrite	Schon existierende Dateien überschreiben

-b, --bewertung		Cutlists nach dem schneiden Bewerten

-d, --debug		Die Ausgabe von Avidemux auf der Konsole anzeigen

-p, --player		Zusammen mit "-b , --bewertung" einsetzbar. Startet vor dem Bewerten einen Videplayer um die Cuts zu überprüfen.

-nb,			Cutlist ohne schneiden bewerten. Hier kann der User eine Cutlist bewerten, ohne das der Film geschnitten wird.

-w, --warn		Ist dies gesetzt, wird die Warnung, das alle Dateien in \$tmp gelöscht werden, nicht angezeigt.

-s, --server [arg]	Hier kann der zu verwendende Server gewählt werden:
			0 = http://cutlist.de (default)
			1 = http://cutlist.mbod.net
			2 = http://cutlist.at.

--toprated		Nicht die erste Cutlist verwenden, sondern die am besten bewertetde. Funktioniert nicht zusammen mit -c, --cutlist

    --version		Version von OtrCut anzeigen

-h, --help		Diese Hilfe ^^

Bitte berichten Sie Fehler an: webmaster@siggimania4u.de

Author: Daniel Siegmanski
Website: http://www.siggimania4u.de
Cutlists: http://www.cutlist.de
HELP
echo -e "${rot}ACHTUNG:${end}"
echo -e "${rot}!!!!!!!Das Script löscht ALLE Dateien im TMP-Verzeichnis!!!!!!!${end}"
exit 0
}

#Hier werden die OPtionen definiert
while [ ! -z "$1" ]; do		#Nur wenn auch eine Optionen gegeben ist, abarbeiten
   case $1 in
     -i          ) input="$2"
                   shift ;;
     --input     ) input="$2"
                   shift;;
     -a	         ) avidemux=yes ;;
     --avidemux  ) avidemux=yes ;;
     -c		 ) cutlist=yes ;;
     --cutlist	 ) cutlist=yes ;;
     -e		 ) error=yes ;;
     --error     ) error=yes ;;
     -l		 ) local=yes
                   cutlist_local=$2
		   shift ;;
     --local     ) local=yes
                   cutlist_local=$2
                   shift ;;
     -t		 ) tmp=$2
                   shift ;;
     --tmp	 ) tmp=$2
                   shift ;;
     -o		 ) output=$2
                   shift ;;
     --output    ) output=$2
                   shift ;;
     -ow         ) overwrite=yes ;;
     --overwrite ) overwrite=yes ;;
     -d		 ) debug=yes ;;
     --debug     ) debug=yes ;;
     -p		 ) play=yes ;;
      --player   ) play=yes ;;
     -nb	 ) nachher=yes ;;
     -h		 ) help ;;
     --help	 ) help ;;
     --version   ) echo "OtrCut Version: $ver"
                   exit 0 ;;
     -b		 ) bewertung=yes ;;
     --bewertung ) bewertung=yes ;;
     --lingui    ) lingui=yes ;;
     -w	         ) warn=no ;;
     --warn      ) warn=no ;;
     -s          ) server=$2
		   shift ;;
     --server    ) server=$2
                   shift ;;
     --toprated  ) toprated=yes ;;
     #*		 ) help ;;
   esac
   shift
done

#Hier werden die Farben definiert, mit denen die Ausgabe eingefärbt wird

if [ "$lingui" == "no" ]; then
   rot="\033[22;31m"	#Rote und fette Schrift
   gruen="\033[22;32m"	#Grüne und fette Schrift
   gelb="\033[22;33m"	#Gelbe und fette Schrift
   end="\033[0m"	#Aufhebung der Farbgebung
else
   rot=""
   end=""
fi

function warnung ()
{
echo -e "${rot}"
cat <<EOF
ACHTUNG!!!
Das Script wird alle Dateien in $tmp löschen.
Sie haben 5 Sekunden um das Script über STRG+C abzubrechen!
EOF
echo -e "${end}"

let warning=5

while [ $warning -gt "0" ]; do
   echo -e -n "${rot}$warning ${end}"
   let warning--
   sleep 1
done
echo ""
echo ""
}

#Hier wird überprüft ob die Optionen richtig angegeben wurden
function test ()
{
#Überprüfe ob eine Eingabedatei angegeben ist
if [ -z $i ]; then		
    echo "${rot}Es wurde keine Eingabedatei angegeben!${end}"
    exit 1
else
    #Überprüfe ob angegebene Datei existiert
    for f in $i; do		
       if [ ! -f $f ]; then
           echo -e "${rot}Eingabedatei nicht gefunden!${end}"
           exit 1
       fi
    done
fi

#Überprüfe ob es die angegebene Cutlist gibt
if [ $local == yes ] && [ -z $cutlist_local ]; then	
    if [ ! -f $cutlist_local ]; then
        echo -e "${rot}Die angegebene Cutlist existiert nicht!${end}"
        exit 1
    fi
fi

#Hier wird überprüft ob die Option -p richtig verwendet wurde.
if [ $play == yes ] && [ $bewertung == no ]; then
   echo -e "${rot}Play kann nur in Zusammenhang mit Bewertung verwendet werden!${end}"
   exit 1
fi

#Hier wird überprüft ob die Optionen -c und -t richtig verwendet wurden.
if [ $toprated == yes ] && [ $cutlist == yes ]; then
   echo -e "${rot}--toprated kann nicht mit -c, --cutlist zusammen verwendet werden!${end}"
   exit 1
fi

#Hier wird überprüft ob der Standart Ausgabeordner verwendet werden soll.
#Wenn ja, wir geprüft ob er verfügbar ist, wenn nicht wird er erstellt.
#Wurde ein alternativer Ausgabeordner gewählt wird geprüft ob er vorhanden ist.
#Ist er nicht vorhanden wird gefragt ob er erstellt werden soll.
if [ $output == "cut" ]; then
    if [ ! -d "cut" ]; then
         mkdir cut
    fi
    echo "Verwende $PWD/cut als Augabeordner"
else
    if [ -d $output ]; then
         echo "Verwende $output als Ausgabeordner"
    else
         echo -e -n ${gelb}$output${end}
         echo -e " ${gelb}wurde nicht gefunden, soll er erstellt werden? [y|n]${end}"
         read OUTPUT
         if [ $OUTPUT == "y" ]; then
              echo -n "Erstele Ordner $output --> "
              mkdir $output
              if [ -d $output ]; then
                   echo -e "${gruen}okay${end}"
              else
                   echo -e "${rot}false${end}"
                   exit 1
              fi
         elif [ $OUTPUT == "n" ]; then
              echo "Ausgabeverzeichnis $output soll nicht erstellt werden."
              exit 1
         else
              echo -e "${rot}Falsche Eingabe!${end}"
              exit 1
        fi
    fi
fi

#Hier wird geprüft ob er Standart TMP-Ordner gewählt wurde oder ein anderer.
#Die Ordner werden auf Wunsch erstellt.
if [ $tmp == "/tmp/otrcut" ]; then 	
    if [ ! -d $tmp ]; then		
        echo -n "Erstelle TMP-Ordner --> "
        mkdir $tmp
        if [ -d $tmp ]; then
             echo -e "${gruen}okay${end}"
             echo "Verwende $tmp als TMP-Ordner"
        else
             echo -e "${rot}false${end}"
             exit 1
        fi
    fi
else
    if [ -d $tmp ]; then
        echo "Verwende $tmp als TMP-Ordner"
    else
        echo -n ${gelb}$tmp${end} 
        echo -e " ${gelb}wurde nicht gefunden, soll er erstellt werden? [y|n]${end}"
        read TMP
        if [ $TMP == "y" ]; then
            echo -n "Erstelle Ordner $tmp --> "
            mkdir $tmp
            if [ -d $tmp ]; then
               echo -e "${gruen}okay${end}"
            else
               echo -e "${rot}false${end}"
               exit 1
            fi
        elif [ $TMP == "n" ]; then
            echo "TMP-Ordner $tmp soll nicht erstellt werden."
            exit 1
        else
            echo "${rot}Falsche Eingabe${end}"
            exit 1
       fi
   fi
fi

if [ "$nacher" == "yes" ]; then
   echo "Die Option "-nb" wurde gesetzt. Es werden nun nur die schon geschnittenen Filme bewertet."
fi

}

#Hier wird geprüft ob die nötige Software installiert ist
function software ()
{
if [ $avidemux == yes ]; then
    echo -n "Überprüfe ob avidemux2_cli installiert ist --> "
    if type -t avidemux2_cli >> /dev/null; then
         echo -e "${gruen}okay${end}"
         aviprog=avidemux2_cli
    else
         echo -e "${rot}false${end}"
    fi
    sleep 0.5
    if [ -z $aviprog ]; then
        echo -n "Überprüfe ob avidemux2 installiert ist --> "
        if type -t avidemux2 >> /dev/null; then
           echo -e "${gruen}okay${end}"
           aviprog=avidemux2
        else
           echo -e "${rot}false${end}"
        fi
    sleep 0.5
    if [ -z $aviprog ]; then
       echo -n "Überprüfe ob avidemux installiert ist --> "
       if type -t avidemux >> /dev/null; then
          echo -e "${gruen}okay${end}"
          aviprog=avidemux
       else
          echo -e "${rot}false${end}"
          echo -e "${rot}Bitte installieren Sie avidemux!${end}"
          exit 1
       fi
    fi
    fi
    sleep 0.5
fi
if [ $avidemux == no ]; then
    for p in avisplit avimerge; do
        echo -n "Überprüfe ob $p installiert ist --> "
        if type -t $p >> /dev/null; then
           echo -e "${gruen}okay${end}"
           aviprog="avisplit"
        else
           echo -e "${rot}false"${end}
           echo -e "${gelb}Bitte installieren Sie das Programm \"transcode\"${end}"
           exit 1
        fi
    done
fi

date_var=$(date -u -d @120 +%T)
if [ "$date_var" == "00:02:00" ]; then
   date_okay=yes
else
   date_okay=no
fi
}

#Hier die Funktion um den Filmnamen und den Cutlistnamen rauszufinden
function name ()
{
film=$i
film_ohne_anfang=$i
if echo "$film_ohne_anfang" | grep -q ".HQ."; then
   film_ohne_ende=${film%%.mpg.HQ.avi}
elif echo "$film_ohne_anfang" | grep -q ".mp4"; then
   film_ohne_ende=${film%%.mpg.mp4}
else
   film_ohne_ende=${film%%.mpg.avi}
fi
CUTLIST=`basename $film`
CUTLIST=${CUTLIST/.avi/}.cutlist
if echo "$film" | grep / >> /dev/null; then
   film_ohne_anfang=${film##*/}
   if echo "$film_ohne_anfang" | grep -q ".HQ."; then
      film_ohne_ende=${film_ohne_anfang%%.mpg.HQ.avi}
   elif echo "$film_ohne_anfang" | grep -q ".mp4"; then
      film_ohne_ende=${film_ohne_anfang%%.mpg.mp4}
   else
      film_ohne_ende=${film_ohne_anfang%%.mpg.avi}
   fi
fi
if [ -n $cutlist_local ]; then
   cutlist_local_op=${cutlist_local##*/}
fi
}

#Cutlist lokal suchen, bzw. eine Auswahl der gefundenen Cutlists ausgeben
function local ()
{
#Hier wird geschaut ob eine Lokale Cutlist angegeben wurde, oder ob aus einer Liste ausgewählt werden soll
if [ -f $cutlist_local ]; then
    cp $cutlist_local $tmp
    CUTLIST=$cutlist_local_op
    vorhanden=yes
    continue=0
else
    echo -e "${rot}Die angegeben Cutlist wurde nicht gefunden!${end}"
    vorhanden=no
    exit 1
fi
if [ -f $tmp/$CUTLIST ]; then
     film_cutlist=`cat $tmp/$CUTLIST | grep ApplyToFile | cut -d= -f2 | tr -d "\r"`
     if [ ! "$film_cutlist" = "$film_ohne_anfang" ]; then
          echo -e "${rot}Die angegebene Cutlist passt nicht zum Film.${end}"
          exit 1
     fi
fi
}

#Hier wird nun versucht ein Cutlist aus dem Internet zu laden falls
#keine Lokale gefunden wurde bzw. Lokal nicht gesucht werden sollte
function load ()
{

function test_cutlist ()
{
let cutlist_size=$(du -b $tmp/$CUTLIST | cut -f1)
   if [ "$cutlist_size" -lt "100" ]; then
      cutlist_okay=no
      rm -rf $tmp/$CUTLIST
   else
      cutlist_okay=yes
   fi
}

if [ "$nachher" == "no" ]; then
echo "Bearbeite folgende Datei: $film"
fi
sleep 1
filesize=`du -b $i | cut -f1 | tr -d "\r"`
#echo $filesize
echo "Laden Cutlistinformationen herunter ..."
if [ "$server" == "0" ]; then
   wget -q -O $tmp/search.xml "http://www.cutlist.de/getxml.php?version=0.9.8.0&ofsb=$filesize"
elif [ "$server" == "1" ]; then
   wget -q -O $tmp/search.xml "http://cutlist.mbod.net/getxml.php?version=0.9.8.0&ofsb=$filesize"
elif [ "$server" == "2" ]; then
   wget -q -O $tmp/search.xml "http://cutlist.mbod.net/getxml.php?version=0.9.8.0&ofsb=$filesize"
fi
let groesse=$(du -b $tmp/search.xml | cut -f1 | tr -d "\r")
if [ "$groesse" -eq "0" ]; then 
   if [ $error == "yes" ]; then
      echo -e "${rot}Cutlist wurde nicht gefunden!${end}"
      exit 1
   elif [ $error == "no" ]; then
      echo -e "${gelb}Cutlist wurde nicht gefunden!${end}"
      continue=1
   fi
elif  [ ! "$server" == "0" ] && [ "$groesse" -lt "77" ]; then
   if [ $error == "yes" ]; then
      echo -e "${rot}Cutlist wurde nicht gefunden!${end}"
      exit 1
   elif [ $error == "no" ]; then
      echo -e "${gelb}Cutlist wurde nicht gefunden!${end}"
      continue=1
   fi
else
   cutlist_anzahl=$(cat $tmp/search.xml | grep -c /cutlist | tr -d "\r")
   let cutlist_anzahl
   if [ $cutlist_anzahl -eq 1 ]; then
        echo "Es wurde eine Cutlist gefunden."
        echo -n "Lade diese nun herunter -->"
        id=$(cat $tmp/search.xml | grep "<id>" | cut -d">" -f2 | cut -d"<" -f1)
	if [ "$server" == "0" ]; then
           wget -q -O $tmp/$CUTLIST "http://cutlist.de/getfile.php?id=$id"
	elif [ "$server" == "1" ]; then 
           wget -q -O $tmp/$CUTLIST "http://cutlist.mbod.net/intget_file.php?id=$id"
	   sleep 2
	elif [ "$server" == "2" ]; then
           wget -q -O $tmp/$CUTLIST "http://cutlist.at/getfile.php?id=$id"
	fi
        test_cutlist
        if [ -f $tmp/$CUTLIST ] && [ "$cutlist_okay" == "yes" ] ; then
            echo -e "${gruen}okay${end}"
            continue=0
        else
            if [ $error == "yes" ]; then
               echo -e "${rot}false${end}"
	       exit 1
	    else
               if [ "$server" == "1" ]; then
		  wget -q -O $tmp/$CUTLIST "http://cutlist.mbod.net/getfile.php?id=$id"
		  sleep 2
                  echo -e "${gruen}okay${end}"
                  continue=0
               else
                  continue=1
	          echo -e "${rot}false${end}"
	       fi
            fi
        fi
   elif [ $cutlist_anzahl -ge "2" ] && [ $continue == "0" ]; then
        echo "Es wurden folgende Cutlists gefunden:"
	echo ""
        let tail=1
        let array=0
        let auswahl=1
        while [ $cutlist_anzahl -ne "0" ]; do
                name[$array]=$(cat $tmp/search.xml | grep "<name>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
                author[$array]=$(cat $tmp/search.xml | grep "<author>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
		ratingbyauthor[$array]=$(cat $tmp/search.xml | grep "<ratingbyauthor>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
		rating[$array]=$(cat $tmp/search.xml | grep "<rating>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
		comment[$array]=$(cat $tmp/search.xml | grep "<usercomment>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
		
		if [ "$toprated" == "no" ] && [ "$cutlist" == "no" ]; then	
		if echo $cutlist_with_error_name | grep -q "${name[$array]}"; then
			echo -ne "${rot}"
		fi
			echo -n "[$array]"
			echo "	Name: ${name[$array]}"
			echo "   	Author: ${author[$array]}"
			echo "   	Rating by Author: ${ratingbyauthor[$array]}"
			if [ "$cutlist_with_error_name" == "no" ]; then
				echo -ne "${gruen}"
			fi
			echo "   	User Rating: ${rating[$array]}"
			if [ "$cutlist_with_error_name" == "no" ]; then
				echo -ne "${end}"
			fi
			echo "   	Kommentar: ${comment[$array]}"
			echo ""
		if echo $cutlist_with_error_name | grep -q "${name[$array]}"; then
			echo -ne "${end}"
		fi
		fi

                let auswahl++
                let tail++
                let cutlist_anzahl--
                let array++
		array1=array
        done
        if [ "$cutlist" = "yes" ]; then
           echo "Es wird die erste Cutlist heruntergeladen."
           sleep 1
           CUTLIST=${name[0]}
           id=$(cat $tmp/search.xml | grep "<id>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n1 | head -n1 | tr -d "\r")
	elif [ "$toprated" == "yes" ]; then
	   echo "Es wird die Cutlist mit der besten User-Bewertung heruntergeladen."
	   let array1--   
	   while [ $array1 -ge 0 ]; do
	      rating1[$array1]=${rating[$array1]}
	      if [ "${rating1[$array1]}" == "" ]; then
		 rating1[$array1]="0.00"
	      fi
	      rating1[$array1]=$(echo ${rating1[$array1]} | sed 's/\.//g')
	      #echo "Rating ohne Komma: ${rating1[$array1]}"
	      let array1--
	   done


           numvalues=${#rating1[@]}

           for (( i=0; i < numvalues; i++ )); do
	      lowest=$i

	      for (( j=i; j < numvalues; j++ )); do
		if [ ${rating1[j]} -ge ${rating1[$lowest]} ]; then
			lowest=$j
		fi
	      done

	      temp=${rating1[i]}
	      rating1[i]=${rating1[lowest]}
	      rating1[lowest]=$temp
           done
           bigest=${rating1[0]}

           beste_bewertung=${bigest%%??}
           beste_bewertung=$beste_bewertung.${bigest##?}
           
	   echo "Die beste Bewertung ist: $beste_bewertung"
           cutlist_nummer=$(cat $tmp/search.xml | grep "<rating>" | grep -n "<rating>$beste_bewertung" | cut -f1 | cut -d":" -f1)
	   id=$(cat $tmp/search.xml | grep "<id>" | head -n $cutlist_nummer | tail -n 1 | cut -d">" -f 2 | cut -d"<" -f 1)
        else
           let array_groesse=$array
           let array_groesse--
           CUTLIST_ZAHL=""
           while [ "$CUTLIST_ZAHL" == "" ]; do
              echo -n "Bitte die Zahl für die zu verwendende Cutlist eingeben: "
              read CUTLIST_ZAHL
	      if [ $CUTLIST_ZAHL -gt $array_groesse ]; then
                echo -e "${gelb}Ungüldige Auswahl.${end}"
                CUTLIST_ZAHL=""
	      fi
	   done

	   let CUTLIST_ZAHL++
	   id=$(cat $tmp/search.xml | grep "<id>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$CUTLIST_ZAHL | head -n1 | tr -d "\r")
           CUTLIST=$(cat $tmp/search.xml | grep "<name>" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$CUTLIST_ZAHL | head -n1 | tr -d "\r")
        fi
	

        echo -n "Lade $CUTLIST herunter ..."
	#echo $id
        if [ "$server" == "0" ]; then
           wget -q -O $tmp/$CUTLIST "http://cutlist.de/getfile.php?id=$id" 
	elif [ "$server" == "1" ]; then 
           wget -q -O $tmp/$CUTLIST "http://cutlist.mbod.net/intget_file.php?id=$id" 
	elif [ "$server" == "2" ]; then
           wget -q -O $tmp/$CUTLIST "http://cutlist.at/getfile.php?id=$id" 
	fi
        test_cutlist
        if [ -f $tmp/$CUTLIST ] && [ "$cutlist_okay" == "yes" ] ; then
            echo -e "${gruen}okay${end}"
            continue=0
        else
            if [ $error == "yes" ]; then
               echo -e "${rot}false${end}"
               exit 1
	    else
               if [ "$server" == "1" ]; then
		  wget -q -O $tmp/$CUTLIST "http://cutlist.mbod.net/getfile.php?id=$id"
		  echo -e "${gruen}okay${end}"
                  continue=0
               else
                  continue=1
                  echo -e "${rot}false${end}"
	       fi
            fi
	fi
   fi
fi
}

#Hier wird nun geprüft um welches Cutlist Format es sich handelt.
function format ()
{
echo -n "Überprüfe um welches Cutlistformat es sich handelt --> "
if cat $tmp/$CUTLIST | grep "StartFrame=" >> /dev/null; then
     echo -e "VCF2Cutlist-Format"
     format=vcf
     sleep 1
elif cat $tmp/$CUTLIST | grep "Start=" >> /dev/null; then
     echo -e "Assistant-Format"
     format=assi
     sleep 1
fi
}

#Hier wird dier heruntergeladene Cutlist überprüft, ob z.B. es keine EPG-Error gab
function cutlist_error ()
{
errors="EPGError MissingBeginning MissingEnding MissingVideo MissingAudio OtherError"

for e in $errors; do
	error_check=$(cat $tmp/$CUTLIST | grep -m 1 $e | cut -d"=" -f2)
	if [ "$error_check" == "1" ]; then
		echo -e "${rot}Es wurde ein Fehler gefunden: \"$e\"${end}"
		error_yes=$e
		if [ "$error_yes" == "OtherError" ]; then
			othererror=$(cat $tmp/$CUTLIST | grep "OtherErrorDescription")
			othererror=${othererror##*=}
			echo -e "${rot}Grund für \"OtherError\": $othererror ${end}"
		fi
		error_found=1
		cutlist_with_error_name="$cutlist_with_error_name $CUTLIST"
	fi
done
}

#Hier werden nun die Zeiten ins richtige Format für avisplit gewandelt.
function time1 ()
{
time=""
unset $cut_anzahl
let cut_anzahl=`cat $tmp/$CUTLIST | grep "NoOfCuts" | cut -d= -f2 | tr -d "\r"`
echo "#####Auflistung der Cuts#####"
if [ $format == "assi" ]; then
    let head1=1
    echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
    while [ $cut_anzahl -gt 0 ]; do
          let time_seconds_start=`cat $tmp/$CUTLIST | grep "Start=" | cut -d= -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 |tr -d "\r"`
          echo "Startcut = $time_seconds_start. Sekunde"
          time=${time}`date -u -d @$time_seconds_start +%T-`
          let time_seconds_ende=`cat  $tmp/$CUTLIST | grep "Duration=" | cut -d= -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | tr -d "\r"`
          let time_seconds_ende=$time_seconds_ende+$time_seconds_start
          echo "Endcut= $time_seconds_ende. Sekunde"
          time=${time}`date -u -d @$time_seconds_ende +%T,`
          let head1++
          let cut_anzahl--
    done
elif [ $format == "vcf" ]; then
    let head1=1
    echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
    while [ $cut_anzahl -gt 0 ]; do
          let startframe=`cat $tmp/$CUTLIST | grep "StartFrame=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r"`
          echo "Startframe= $startframe"
          time="${time}$startframe-"
          let stopframe=`cat $tmp/$CUTLIST | grep "DurationFrames=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r"`
          let stopframe=$stopframe+$startframe
          echo "Endframe= $stopframe"
          time="${time}$stopframe,"
          let head1++
          let cut_anzahl--
    done
fi
echo "#####ENDE#####"
sleep 1
}

#Hier werden nun die Zeiten ins richtige Format gebracht, falls die date-variante nicht funktioniert
function time2 ()
{
time=""
unset $cut_anzahl
let cut_anzahl=`cat $tmp/$CUTLIST | grep "NoOfCuts" | cut -d= -f2 | tr -d "\r"`
echo "#####Auflistung der Cuts#####"
if [ $format == "assi" ]; then
   let head1=1
   echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
   while [ $cut_anzahl -gt 0 ]; do
      let time_seconds_start=`cat $tmp/$CUTLIST | grep "Start=" | cut -d= -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | tr -d "\r"`
      let ss=$time_seconds_start
      let mm=0
      let hh=0
      while [ $ss -ge "60" ]; do
         let mm++
         let ss=$ss-60
         while [ $mm -ge "60" ]; do
            let hh++
            let mm=$mm-60
         done
      done
      time2_start=$hh:$mm:$ss
      echo "Startcut= $time2_start"
      time="${time}${time2_start}-"
      let time_seconds_ende=`cat  $tmp/$CUTLIST | grep "Duration=" | cut -d= -f2 | head -n$head1 | tail -n1 | cut -d"." -f1 | tr -d "\r"`
      let time_seconds_ende=$time_seconds_ende+$time_seconds_start
      let ss=$time_seconds_ende
      let mm=0
      let hh=0
      while [ $ss -ge "60" ]; do
         let mm++
         let ss=$ss-60
         while [ $mm -ge "60" ]; do
            let hh++
            let mm=$mm-60
         done
      done
      time2_ende=$hh:$mm:$ss
      echo "Endcut= $time2_ende"
      time="${time}${time2_ende},"
   done
elif [ $format == "vcf" ]; then
    let head1=1
    echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
    while [ $cut_anzahl -gt 0 ]; do
          let startframe=`cat $tmp/$CUTLIST | grep "StartFrame=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r"`
          echo "Startframe= $startframe"
          time="${time}$startframe-"
          let stopframe=`cat $tmp/$CUTLIST | grep "DurationFrames=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r"`
          let stopframe=$stopframe+$startframe
          echo "Endframe= $stopframe"
          time="${time}$stopframe,"
          let head1++
          let cut_anzahl--
    done
fi
echo "#####ENDE#####"
sleep 1
}

#Hier wird nun, falls avisplit gewählt wurde, avisplit gestartet
function split ()
{
echo "Übergebe die Cuts nun an avisplit"
avisplit -i $film -o "$output/$film_ohne_ende-cut.avi" -t $time -c &&
if [ -f $output/$film_ohne_ende-cut.avi ]; then
     echo -n -e ${gruen}$output/$film_ohne_ende${end}
     echo -e "${gruen}-cut.avi wurde erstellt${end}"
else
     echo -e "${rot}Avisplit muss einen Fehler verursacht haben${end}"
     if [ $error == "yes" ]; then
          exit 1
     else
          continue=1
     fi
fi
}

#Hier wird nun, falls avidemux gewählt wurde, avidemux gestartet
function demux ()
{
function start ()
{
cat << EOF
//AD  <- Needed to identify//
var app = new Avidemux();

//** Video **
// 01 videos source 
app.load("$film");
EOF
}
start >> $tmp/avidemux.js

echo "//$cut_anzahl segments" >> $tmp/avidemux.js
echo "app.clearSegments();" >> $tmp/avidemux.js

let cut_anzahl=`cat $tmp/$CUTLIST | grep "NoOfCuts" | cut -d= -f2 | tr -d "\r"`
echo "#####Auflistung der Cuts#####"
if [ "$format" = "assi" ]; then
    let head2=1
    echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
    while [ "$cut_anzahl" -gt 0 ]; do
          let time_seconds_start=`cat $tmp/$CUTLIST | grep "Start=" | cut -d= -f2 | head -n$head2 | tail -n1 | cut -d"." -f1 | tr -d "\r"`
          let time_frame_start=$time_seconds_start*25
          echo "Startframe= $time_frame_start"
          let time_seconds_dauer=`cat  $tmp/$CUTLIST | grep "Duration=" | cut -d= -f2 | head -n$head2 | tail -n1 | cut -d"." -f1 | tr -d "\r"`
          let time_frame_dauer=$time_seconds_dauer*25
          echo "Dauer= $time_frame_dauer"
          echo "app.addSegment(0,$time_frame_start,$time_frame_dauer);" >> $tmp/avidemux.js
          let head2++
          let cut_anzahl--
    done
elif [ "$format" = "vcf" ]; then
    let head2=1
    echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
    while [ $cut_anzahl -gt 0 ]; do
          let startframe=`cat $tmp/$CUTLIST | grep "StartFrame=" | cut -d= -f2 | head -n$head2 | tail -n1 | tr -d "\r"`
          echo "Startframe= $startframe"
          let dauerframe=`cat $tmp/$CUTLIST | grep "DurationFrames=" | cut -d= -f2 | head -n$head2 | tail -n1 | tr -d "\r"`
          echo "Dauer= $dauerframe"
          echo "app.addSegment(0,$startframe,$dauerframe);" >> $tmp/avidemux.js
          let head2++
          let cut_anzahl--
    done
fi
echo "#####ENDE#####"
sleep 1

if echo "$film_ohne_anfang" | grep -q ".HQ."; then
   outputfile="$output/$film_ohne_ende.HQ-cut.avi"
elif echo "$film_ohne_anfang" | grep -q ".mp4"; then
   outputfile="$output/$film_ohne_ende-cut.mp4"
else
   outputfile="$output/$film_ohne_ende-cut.avi"
fi

function ende ()
{ 
cat << EOF

//** Postproc **
app.video.setPostProc(3,3,0);
app.video.setFps1000(25000);

//** Filters **

//** Video Codec conf **
app.video.codec("Copy","CQ=4","0 ");

//** Audio **
app.audio.reset();
app.audio.codec("copy",128,0,"");
app.audio.normalizeMode=0;
app.audio.normalizeValue=0;
app.audio.delay=0;
app.audio.mixer("NONE");
app.audio.scanVBR();
app.setContainer("AVI");
setSuccess(app.save("$outputfile"));
//app.Exit();

//End of script
EOF
}

ende >> $tmp/avidemux.js

echo "Übergebe die Cuts nun an avidemux"

if [ "$debug" == "yes" ]; then
	$aviprog --nogui --force-smart --run $tmp/avidemux.js --quit
elif [ "$debug" == "no" ]; then
	$aviprog --nogui --force-smart --run $tmp/avidemux.js --quit >> /dev/null
fi

if [ -f $outputfile ]; then
     echo -n -e  ${gruen}$outputfile${end}
     echo -e "${gruen} wurde erstellt${end}"
else
     echo -e "${rot}Avidemux muss einen Fehler verursacht haben${end}"
     if [ $error == "yes" ]; then
          exit 1
     else
          continue=1
     fi
fi
}

#Hier wird nun, wenn gewünscht, eine Bewertung für die Cutlist abgegeben
function bewertung ()
{
if [ ! "$server" == "0" ]; then
   echo -e "${gelb}Die Bewertungsfunktion steht auf http://cutlist.mbod.net und http://cutlist.at nicht zur verfügung!${end}"
   sleep 2
elif [ "$server" == "0" ]; then
   echo ""
   echo "Sie können nun eine Bewerung für die Cutlist abgeben."
   echo "Folgende Noten stehen zur verfügung:"
   echo "[0] Test (schlechteste Wertung)"
   echo "[1] Anfang und Ende geschnitten"
   echo "[2] +/- 5 Sekunden"
   echo "[3] +/- 1 Sekunde"
   echo "[4] Framegenau"
   echo "[5] Framegenau und keine doppelten Szenen"
   echo ""
   echo "Sollten Sie für diese Cutlist keine Bewertung abgeben wollen,"
   echo "drücken Sie einfach ENTER."
   echo -n "Note: "
   note=""
   read note
   while [ ! "$note" == "" ] && [ "$note" -gt "5" ]; do
	   note=""
	   echo -e "${gelb}Ungültige Eingabe, bitte nochmal:${end}"
	   read note
   done
   if [ "$note" == "" ]; then
	   echo "Für diese Cutlist wird keine Bewertung abgegeben."
   else
	   echo -n "Übermittle Bewertung für $CUTLIST -->"
	   wget -q -O $tmp/rate.php "http://cutlist.de/rate.php?rate=$id&rating=$note&userid=$user&version=0.9.8.7" &&
	   sleep 3
	   if [ -f "$tmp/rate.php" ]; then
		   if cat "$tmp/rate.php" | grep -q "Cutlist nicht von hier. Bewertung abgelehnt."; then
		      echo -e " ${rot}False${end}"	
		      echo -e " ${rot}Die Cutlist ist nicht von http://cutlist.de und kann nicht bewertet werden.${end}"
		   elif cat "$tmp/rate.php" | grep -q "Du hast schon eine Bewertung abgegeben oder Cutlist selbst hochgeladen."; then
		      echo -e " ${rot}False${end}"
		      echo -e "${rot}Du hast für die Cutlist schonmal eine Bewertung abgegeben oder sie selbst hochgeladen.${end}"
		   elif cat "$tmp/rate.php" | grep -q " Cutlist wurde bewertet"; then
		      echo -e "${gruen}Okay${end}"
		      echo -e "${gruen}Cutlist wurde bewertet${end}"
		   fi
	   else
		   echo -e "${rot}False${end}"
		   echo -e "${rot}Bewertung fehlgeschlagen.${end}"
	   fi
   fi
fi
}	

#Hier werden nun die temporären dateien gelöscht
function del_tmp ()
{
if [ "$tmp" == "" ] || [ "$tmp" == "/" ] || [ "$tmp" == "/home" ]; then
	echo -e "${rot}Achtung, bitte überprüfen sie die Einstallung von \$tmp${end}"
	exit 1
fi
echo "Lösche temporäre Dateien"
rm -rf $tmp/*
}


if [ "$warn" == "yes" ]; then
   warnung
fi
del_tmp
if [ "$server" == "0" ]; then
   echo "Verwende  http://cutlist.de als Server."
elif [ "$server" == "1" ]; then
   echo "Verwende http://cutlist.mbod.net als Server"
elif [ "$server" == "2" ]; then
   echo "Verwende http://cutlist.at als Server"
fi
software
if [ "$nachher" == "no" ]; then
   for i in $input; do
       test
       name
       if [ $local == "yes" ]; then
           local
       fi
       while true; do
      	 if [ $local == "no" ] || [ $vorhanden == "no" ]; then
           	load
       	fi
       	if [ $continue == "0" ]; then
         	  format
	fi
	if [ $continue == "0" ]; then
		cutlist_error
	fi
	if [ "$error_found" == "1" ]; then
		echo -e "${gelb}In der Cutlist wurde ein Fehler gefunden, soll sie verwendet werden? [y|n]${end}"
		read error_antwort
		if [ "$error_antwort" == "y" ]; then
			echo -e "${gelb}Verwende die Cutlist trotz Fehler!${end}"
			break
		else
			echo "Bitte neue Cutlist wählen!"
		fi
	else
		break
	fi
       done
       if [ "$aviprog" = "avisplit" ] && [ $continue == "0" ]; then
           if [ "$date_okay" = "yes" ]; then
              time1
           elif [ "$date_okay" = "no" ]; then
              time2
           fi
           if [ "$overwrite" == "no" ]; then
              if [ ! -f "$output/$film_ohne_ende-cut.avi" ]; then
                 split
              else
                 echo -e "${gelb}Die Ausgabedatei existiert bereits!${end}"
                 if [ $error == "yes" ]; then
                    exit 1
                 else
                    continue=1
                 fi
              fi
           fi
           if [ "$overwrite" == "yes" ]; then
              split
           fi
       fi
       if [ "$aviprog" = "avidemux" ] || [ "$aviprog" = "avidemux2" ] || [ "$aviprog" = "avidemux2_cli" ] && [ $continue == "0" ]; then
           if [ "$overwrite" == "no" ]; then
              if [ ! -f "$output/$film_ohne_ende-cut.avi" ]; then
                 demux
              else
                 echo -e "${gelb}Die Ausgabedatei existiert bereits!${end}"
                 if [ $error == "yes" ]; then
                    exit 1
                 else
                    continue=1
                 fi
              fi
           fi
           if [ "$overwrite" == "yes" ]; then
              demux
           fi
       fi
       if [ "$local" == "no" ] && [ "$bewertung" == "yes" ] && [ ! "$continue" == "1" ]; then
	   if [ "$play" == "no" ]; then
	      bewertung
	   elif [ "$play" == "yes" ]; then
	      echo "Starte nun den gewählten Videoplayer"
	      sleep 1
              $player "$output/$film_ohne_ende-cut.avi" &&
              bewertung
	   fi
       fi
   del_tmp
   continue=0
   done
fi
if [ "$nachher" == "yes" ]; then
   for i in $input; do
      echo "Folgende Filme werden bewertet:"
      echo ""
      echo $input
      echo ""
      echo "Starte Bewertung für >$i<"
      echo ""
      name
      load
      bewertung
      del_tmp
   done
fi


###END OF SCRIPT###