#!/bin/bash

#Dieses Script schneidet Filme/Serien von http://www.onlinetvrecorder.de anhand der Schnittlisten von
#http://www.cutlist.de und http://www.cutlist.at.
#Dies geschieht entweder durch avidemux oder avisplit/avimerge.
#Avidemux schneidet im Gegensatz zu avisplit/avimerge keyframe genau.
#avisplit/avimerge ist Bestandteil von transcode, avidemux muss seperat installiert werden.
#
#Dieses Script darf frei verändert und weitergegeben werden.
#
#Author: Daniel Siegmanski
#Homepage: http://www.siggimania4u.de
#OtrCut Download: http://otrcut.siggimania4u.de

#Hier werden verschiedene Variablen definiert.
version=2008122-test	#Die Version von OtrCut, Format: yyyymmdd, yyyy=Jahr mm=Monat dd=Tag
LocalCutlistOkay=no	#Ist die lokale Cutlist vorhanden?
input=""		#Eingabedatei/en
CutProg=""		#Zu verwendendes Schneideprogramm
LocalCutlistName=""	#Name der lokalen Cutlist
format=""		#Um welches Format handelt es sich? AVI, HQ, mp4
cutlistWithError=""	#Cutlists die einen Fehler haben
delete=no
continue=0
rot="\033[22;31m"	#Rote Schrift
gruen="\033[22;32m"	#Grüne Schrift
gelb="\033[22;33m"	#Gelbe Schrift
blau="\033[22;34m"	#Blaue Schrift
normal="\033[0m"	#Normale Schrift

#Dieses Variablen werden nur gesetzt wenn keine Config-Datei existiert
if [ ! -f ~/.otrcut ]; then
	UseLocalCutlist=no	#Lokale Cutlists verwenden?
	HaltByErrors=no		#Bei Fehlern anhalten?
	first=no		#Die erste gefundene Cutlist verwenden?
	toprated=no		#Die Cutlist mit der besten User-Bewertung benutzen?
	UseAvidemux=yes		#Avidemux verwenden?
	ShowAllCutlists=yes	#Auswahl mehrerer Cutlists anzeigen?
	tmp="/tmp/otrcut"	#Zu verwendender Tmp-Ordner, in diesem Ordner wird dann noch ein Ordner "otrcut" erstellt.
	overwrite=no		#Bereits vorhandene Dateien überschreiben
	output=cut		#Ausgabeordner
	bewertung=no		#Bewertungsfunktion benutzen
	verbose=no		#Ausführliche Ausgabe von avidemux bzw. avisplit/avimerge anzeigen
	play=no			#Datei nach dem Schneiden wiedergeben
	warn=yes		#Warnung bezüglich der Löschung von $tmp ausgeben
	user=otrcut		#Benutzer der zum Bewerten benutzt wird
	player=mplayer		#Mit diesem Player wird das Video wiedergegeben sofern $play auf yes steht
	decode=no		#Decoder integrieren

	#Diese Variablen werden vom Benutzer gesetzt.
	#Sie sind für die Verwendung des Decoders gedacht.
	email="" #Die EMail-Adresse mit der Sie bei OTR registriert sind
	password="" #Das Passwort mit dem Sie sich bei OTR einloggen
	decoder="otrdecoder" #Pfad zum decoder. Z.B. /home/benutzer/bin/otrdecoder
else
	source ~/.otrcut
fi
	
#Diese Funktion gibt die Hilfe aus
function help ()
{
cat <<HELP
OtrCut Version: $version

Dieses Script schneidet OTR-Dateien anhand der Cutlist von http://cutlist.de, http://cutlist.at und http://cutlist.mbod.net.
Wenn kein spezieller Server gewählt wird, werden alle Server durchsucht.
Es können entweder die Tools avidemux oder avisplit/avimerge benutzt werden.
Avidemux kann im Gegensatz zu avisplit auch zwischen Keyframes schneiden.
Hier die Anwendung:

$0 [optionen] -i film.mpg.avi

Optionen:

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

-a, --avisplit		Avisplit und avimerge anstelle von avidemux verwenden

-f, --first		Falls mehrere Cutlists zur Verfügung stehen, wird immer die mit der besten Bewertung benutzt

-e, --error		Bei Fehlern das Script beenden

--tmp [arg]		TMP-Ordner angeben (Standart: /tmp/), In diesem Ordner wird noch ein Ordner "otrcut" angelegt, ACHTUNG: ALLE Daten in \$tmp werden gelöscht!!!

-l, --local 		Lokale Cutlists verwenden (Cutlists werden im aktuellen Verzeichnis gesucht)

-d, --decode		OtrDecoder integrieren (Variablen müssen gesetzt sein! Zeile 52-54 im Script, oder in externer Config)

--delete		Quellvideo nach Schneidevorgang löschen (Wenn "decode" gwählt wurde, wird das OtrKey auch gelöscht.)

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

-ow, --overwrite	Schon existierende Ausgabedateien überschreiben

-b, --bewertung		Bewertungsfunktion aktivieren

-p, --play		Zusammen mit "-b, --bewertung" einsetzbar, startet vor dem Bewerten das Video in einem Videoplayer

-w, --warn		Warnung bezüglich Löschung aller Dateien in \$tmp unterdrücken

--toprated		Verwendet die best bewertetste Cutlist

-v, --verbose		Ausführliche Ausgabe von avidemux bzw. avimerge/avisplit aktivieren

-u, --update		Nach einer neuen Version von OtrCut suchen

-h, --help		Diese Hilfe ^^

Author: Daniel Siegmanski
Homepage: http://www.siggimania4u.de
Cutlists: http://www.cutlist.de, http://www.cutlist.at, http://cutlist.mbod.net

HELP
exit 0
}

#Diese Funktion sucht nach einer neuen Version von OtrCut
function update ()
{
online_version=$(wget -q -O - http://otrcut.siggimania4u.de/version | tr -d "\r")

if [ "$online_version" -gt "$version" ]; then
	echo -e "${blau}Es ist eine neue Version verfügbar.${normal}"
	echo -e "${blau}Verwendete Version: $version ${normal}"
	echo -e "${blau}Aktuelle Version: $online_version ${normal}"
	echo "Die neue Version kann unter \"http://otrcut.siggimania4u.de\" heruntergeladen werden."
else
	echo -e "${gelb}Es wurde keine neuere Version gefunden.${normal}"
fi

exit 0
}

#Hier werden die übergebenen Option ausgewertet
while [ ! -z "$1" ]; do
	case $1 in
		-i | --input )	input="$2"
				shift ;;
		-a | --avisplit )	UseAvidemux=no ;;
		-f | --first )	first=yes ;;
		-e | --error )	HaltByErrors=yes ;;
		-d | --decode )	decode=yes ;;
		--delete )	delete=yes ;;
		-l | --local )	UseLocalCutlist=yes ;;
		-t | --tmp )	tmp=$2
				shift ;;
		-o | --output )	output=$2
				shift ;;
		-ow | --overwrite )	overwrite=yes ;;
		-v | --verbose )	verbose=yes ;;
		-p | --play )	play=yes ;;
		-b | --bewerten)	bewertung=yes ;;
		-w | --warn )	warn=no ;;
		--toprated )	toprated=yes ;;
		-u | --update )	update ;;
		-h | --help )	help ;;
	esac
	shift
done

#Diese Funktion gibt die Warnung bezüglich der Löschung von $tmp aus
function warnung ()
{
if [ "$warn" == "yes" ]; then
	echo -e "${rot}"
	echo "ACHTUNG!!!"
	echo "Das Script wird alle Dateien in $tmp/otrcut löschen!"
	echo "Sie haben 5 Sekunden um das Script über STRG+C abzubrechen"
	
	for (( I=5; I >= 1 ; I-- )); do
		echo -n "$I "
		sleep 1
	done
	echo -e "${normal}"
	echo ""
	echo ""
fi
}

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

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

#Hier wird überprüft ob --first und --toprated nicht zusammen benutzt werden
if [ "$toprated" == "yes" ] && [ "$first" == "yes" ]; then
	echo -e "${rot}\"First\" kann nicht in Verbindung mit \"toprated\" verwendet werden.${normal}"
	exit 1
fi

#Hier wird überprüft ob der Standardausgabeordner verwendet werden soll.
#Wenn ja, wird überprü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
		if [ -w $PWD ]; then
			mkdir cut
			echo "Verwende $PWD/cut als Ausgabeordner"
		else
			echo -e "${rot}Sie haben keine Schreibrechte im aktuellen Verzeichnis ($PWD).${normal}"
			exit 1
		fi
	fi
else
	if [ -d "$output" ] && [ -w "$output" ]; then
		echo "Verwende $output als Ausgabeordner."
	elif [ -d "$output" ] && [ ! -w "$output" ]; then
		echo -e "${rot}Sie haben keine Schreibrechte in $output.${normal}"
		exit 1
	else
		echo -e "${gelb}Das Verzeichnis $output wurde nicht gefunden, soll er erstellt werden? [y|n]${normal}"
		read OUTPUT
		while [ "$OUTPUT" == "" ] || [ ! "$OUTPUT" == "y" ] && [ ! "$OUTPUT" == "n" ]; do #Bei falscher Eingabe
			echo -e "${gelb}Falsche Eingabe, bitte nochmal:${normal}"
			read OUTPUT
		done
		if [ "$OUTPUT" == "n" ]; then	#Wenn der Benutzer nein "sagt"
			echo "Ausgabeverzeichnis \"$output\" soll nicht erstellt werden."
			exit 1
		elif [ "$OUTPUT" == "y" ]; then	#Wenn der Benutzer ja "sagt"
			echo -n "Erstelle Ordner $output -->"
			mkdir $output
			if [ -d "$output" ]; then
				echo -e "${gruen}okay${normal}"
			else
				echo -e "${rot}false${normal}"
				exit 1
			fi
		fi
	fi
fi

#Hier wird überprüft ob der Standard-Tmpordner verwendet werden soll.
#Wenn ja, wird überprüft ob er verfügbar ist, wenn nicht wird er erstellt.
#Wurde ein alternativer Tmpordner gewählt, wird geprüft ob er vorhanden ist.
#Ist er nicht vorhanden wird gefragt ob er erstellt werden soll.
if [ "$tmp" == "/tmp/otrcut" ]; then
	if [ ! -d "/tmp/otrcut" ]; then
		if [ -w /tmp ]; then
			mkdir "/tmp/otrcut"
			echo "Verwende $tmp/otrcut als Ausgabeordner"
			#tmp="$tmp/otrcut"
		else
			echo -e "${rot}Sie haben keine Schreibrechte in /tmp/ ${end}"
			exit 1
		fi
	fi
else
	if [ -d "$tmp" ] && [ -w "$tmp" ]; then
		mkdir "$tmp/otrcut"
		echo "Verwende $tmp/otrcut als Ausgabeordner."
		tmp="$tmp/otrcut"
	elif [ -d "$tmp" ] && [ ! -w "$tmp" ]; then
		echo -e "${rot}Sie haben keine Schreibrechte in $tmp!${end}"
	else
		echo -e "${gelb}$tmp wurde nicht gefunden, soll er erstellt werden? [y|n]${end}"
		read TMP	#Lesen der Benutzereingabe nach $TMP
		while [ "$TMP" == "" ] || [ ! "$TMP" == "y" ] && [ ! "$TMP" == "n" ]; do	#Bei falscher Eingabe	
			echo -e "${gelb}Falsche Eingabe, bitte nochmal:${end}" 
			read TMP	#Lesen der Benutzereingabe nach $TMP
		done
		if [ $TMP == n ]; then	#Wenn der Benutzer nein "sagt"
			echo "Tempverzeichnis \"$tmp\" soll nicht erstellt werden."
			exit 1
		elif [ $TMP == y ]; then	#Wenn der Benutzer ja "sagt"
			echo -n "Erstelle Ordner $tmp --> "
			mkdir "$tmp/otrcut"
			if [ -d $tmp/otrcut ]; then
				echo -e "${gruen}okay${end}"
				tmp="$tmp/otrcut"
			else
				echo -e "${rot}false${end}"
				exit 1
			fi
		fi
	fi
fi
}

#Diese Funktion überprüft ob avidemux installiert ist
function software ()
{
if [ "$UseAvidemux" == "yes" ]; then
	for s in avidemux2_cli avidemux2_qt4 avidemux2_gtk avidemux2 avidemux; do
		if [ -z $CutProg ]; then
			echo -n "Überprüfe ob $s installiert ist --> "
			if type -t $s >> /dev/null; then
				echo -e "${gruen}okay${normal}"
				CutProg="$s"
			else
				echo -e "${rot}false${normal}"
			fi
		fi
	done
fi

#Hier wird überprüft ob avisplit und avimerge installiert sind
if [ "$UseAvidemux" == "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${normal}"
			CutProg="avisplit"
		else
			echo -e "${rot}false${normal}"
			echo -e "${gelb}Installieren Sie transcode!${normal}"
			exit 1
		fi
	done
fi

#Hier wird überprüft ob date zum umrechnen der Zeit benutzt werden kann
echo -n "Überprüfe welche Methode zum Umrechnen der Zeit benutzt wird --> "
date_var=$(date -u -d @120 +%T)
if [ "$date_var" == "00:02:00" ]; then
	echo -e "${blau}date${normal}"
	date_okay=yes
else
	echo -e "${gelb}intern${normal}"
	date_okay=no
fi

#Hier wird überprüft ob der richtige Pfad zum Decoder angegeben wurde
if [ "$decode" == "yes" ]; then
	echo -n "Überprüfe ob der Decoder-Pfad richtig gesetzt wurde --> "
	if $decoder -v >> /dev/null; then
		echo -e "${gruen}okay${normal}"
	else
		echo -e "${rot}false${normal}"
		exit 1
	fi
if [ "$email" == "" ]; then
	echo -e "${rot}EMail-Adresse wurde nicht gesetzt.${normal}"
	exit 1
fi
if [ "$password" == "" ]; then
	echo -e "${rot}Passwort wurde nicht gesetzt.${normal}"
	exit 1
fi
fi
}

#Diese Funktion definiert den Cutlist- und Dateinamen und üperprüft um welches Dateiformat es sich handelt
function name ()
{
film=$i	#Der komplette Filmname und gegebenfalls der Pfad
film_ohne_anfang=$i
if [ "$decode" == "yes" ]; then
	film_ohne_anfang=${film_ohne_anfang%%.otrkey}
	film=$tmp/$film_ohne_anfang
fi
CUTLIST=`basename $film`	#Filmname ohne Pfad
echo -n "Überprüfe um welches Aufnahmeformat es sich handelt --> "
if echo "$film_ohne_anfang" | grep -q ".HQ."; then	#Wenn es sich um eine "HQ" Aufnahme handelt
	film_ohne_ende=${film%%.mpg.HQ.avi}	#Filmname ohne Dateiendung
	CUTLIST=${CUTLIST/.avi/}.cutlist	#Der lokale Cutlistname
	format=hq
	echo -e "${blau}HQ${normal}"
elif echo "$film_ohne_anfang" | grep -q ".mp4"; then	#Wenn es sich um eine "mp4" Aufnahme handelt
	film_ohne_ende=${film%%.mpg.mp4}	#Filmname ohne Dateiendung
	format=mp4
	CUTLIST=${CUTLIST/.mp4/}.cutlist	#Der lokale Cutlistname
	echo -e "${blau}mp4${normal}"
else
	film_ohne_ende=${film%%.mpg.avi}	#Filmename ohne Dateiendung
	format=avi
	CUTLIST=${CUTLIST/.avi/}.cutlist	#Der lokale Cutlistname
	echo -e "${blau}avi${normal}"
fi

if echo "$film" | grep / >> /dev/null; then	#Wenn der Dateiname einen Pfad enthält
	film_ohne_anfang=${film##*/}	#Filmname ohne Pfad
	if echo "$film_ohne_anfang" | grep -q ".HQ."; then	#Wenn es sich um eine "HQ" Aufnahme handelt
		film_ohne_ende=${film_ohne_anfang%%.mpg.HQ.avi}
		format=hq
	elif echo "$film_ohne_anfang" | grep -q ".mp4"; then	#Wenn es sich um eine "mp4" Aufnahme handelt
		film_ohne_ende=${film_ohne_anfang%%.mpg.mp4}
		format=mp4
	else
		film_ohne_ende=${film_ohne_anfang%%.mpg.avi}
		format=avi
	fi
fi

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
}

#In dieser Funktion wir die lokale Cutlist überprüft
function local ()
{
local_cutlists=$(ls *.cutlist)	#Variable mit allen Cutlists in $PWD
filesize=$(du -b $film | cut -f1 | tr -d "\r") #Dateigröße des Filmes
let goodCount=0	#Passende Cutlists
let arraylocal=1	#Nummer des Arrays
for f in $local_cutlists; do
	echo -n "Überprüfe ob eine der gefundenen Cutlists zum Film passt --> "
	if [ -z $f ]; then
		echo -e "${rot}Keine Cutlist gefunden!${normal}"
		if [ "$HaltByErrors" == "yes" ]; then
			exit 1
		else
			vorhanden=no
			continue=1
		fi
	fi

	OriginalFileSize=$(cat $f | grep OriginalFileSizeBytes | cut -d"=" -f2 | tr -d "\r")	#Dateigröße des Films

	if cat $f | grep -q "$film"; then	#Wenn der Dateiname mit ApplyToFile übereinstimmt
		echo -e -n "${blau}ApplyToFile ${normal}"
		ApplyToFile=yes	
		vorhanden=yes
	fi
	if [ "$OriginalFileSize" == "$filesize" ]; then	#Wenn die Dateigröße mit OriginalFileSizeBytes übereinstimmt
		echo -e -n "${blau}OriginalFileSizeBytes${normal}"
		OriginalFileSizeBytes=yes 
		vorhanden=yes
	fi
	if [ "$vorhanden" == "yes" ]; then	#Wenn eine passende Cutlist vorhanden ist
		let goodCount++
		namelocal[$arraylocal]="$f"
		#echo $f
		#echo ${namelocal[$arrylocal]}
		let arraylocal++
		continue=0
	else
		echo -e "${rot}false${normal}"
	fi		
done

if [ "$goodCount" -eq 1 ]; then	#Wenn nur eine Cutlist gefunden wurde
	echo "Es wurde eine passende Cutlist gefunden. Diese wird nun verwendet."
	CUTLIST="$f"
	cp $CUTLIST $tmp
elif [ "$goodCount" -gt 1 ]; then	#Wenn mehrere Cutlists gefunden wurden
	echo "Es wurden $goodCount Cutlists gefunden. Bitte wählen Sie aus:"
	echo ""
	let number=1
	for (( i=1; i <= $goodCount ; i++ )); do
		
		echo "$number: ${namelocal[$number]}"
		let number++
	done
	echo -n "Bitte die Nummer der zu verwendenden Cutlist eingeben:"
	read NUMBER
	while [ "$NUMBER" -gt "$goodCount" ]; do
		echo "${rot}false. Noch mal:${normal}"
		read NUMBER
	done
	echo "Verwende ${namelocal[$NUMBER]} als Cutlist."
	CUTLIST=$namelocal[$NUMBER]
	cp $CUTLIST $tmp
	vorhanden=yes
fi
}

#In dieser Funktion wird versucht eine Cutlist aus den Internet zu laden
function load ()
{
#In dieser Funktion wird geprüft, ob die Cutlist okay ist
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
}

echo -e "Bearbeite folgende Datei: ${blau}$film${normal}"
sleep 1
filesize=$(du -b $i | cut -f1 | tr -d "\r")
#echo $filesize
for g in cutlist.de cutlist.at; do
	echo -n "Führe Suchanfrage bei \"$g\" durch ---> "
	wget -q -O $tmp/$g "http://$g/getxml.php?version=0.9.8.0&ofsb=$filesize" &&
	if grep -q '<id>' "$tmp/$g"; then
		echo -e "${gruen}okay${normal}"
		server="${server} ${g}"
	else
		echo -e "${rot}false${normal}"
	fi
done

for g in cutlist.de cutlist.at; do	
	#Hier wird die Suchanfrage überprüft
	if [ "$server" == "" ]; then
		echo -e "${rot}Es wurden keine Cutlists auf $g gefunden.${normal}"
		if [ "$HaltByErrors" == "yes" ]; then
			exit 1
		else
			continue=1
		fi
	else
		if [ "$schon_mal_angezeigt" == "" ]; then
			echo -e "${blau}Cutlist/s gefunden.${normal}"
			echo ""
			echo "Es wurden folgende Cutlists gefunden:"
			schon_mal_angezeigt=yes
			let array=0
		fi
		cutlist_anzahl=$(grep -c '/cutlist' "$tmp/$g" | tr -d "\r") #Anzahl der gefundenen Cutlists
		let cutlist_anzahl
		if [ "$cutlist_anzahl" -ge "1" ] && [ "$continue" == "0" ]; then #Wenn mehrere Cutlists gefunden wurden
			echo ""
			let tail=1
			while [ "$cutlist_anzahl" -gt "0" ]; do
				#Name der Cutlist
				name[$array]=$(grep "<name>" "$tmp/$g" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
				#Author der Cutlist
				author[$array]=$(grep "<author>" "$tmp/$g" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
				#Bewertung des Authors
				ratingbyauthor[$array]=$(grep "<ratingbyauthor>" "$tmp/$g" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
				#Bewertung der User
				rating[$array]=$(grep "<rating>" "$tmp/$g" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
				#Kommentar des Authors
				comment[$array]=$(grep "<usercomment>" "$tmp/$g" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
				#ID der Cutlist
				ID[$array]=$(grep "<id>" "$tmp/$g" | cut -d">" -f2 | cut -d"<" -f1 | tail -n$tail | head -n1 | tr -d "\r")
				#Server auf dem die Cutlist gefunden wurde
				server[$array]=${g}

				if [ "$toprated" == "no" ]; then #Wenn --toprated nicht gesetzt ist
					if echo $cutlistWithError | grep -q "${ID[$array]}"; then #Wenn Fehler gesetzt ist z.B. EPG-Error oder MissingBeginning
						echo -ne "${rot}"
					fi
					echo -n "[$array]"
					echo "  Name: ${name[$array]}"
					echo "     Author: ${author[$array]}"
					echo "     Rating by Author: ${ratingbyauthor[$array]}"
					if [ -z "$cutlistWithError" ]; then
						echo -ne "${gruen}"
					fi
					echo "     Rating by Users: ${rating[$array]}"
					if [ -z "$cutlistWithError" ]; then
						echo -ne "${normal}"
					fi
					echo "     Kommentar: ${comment[$array]}"
					echo "     ID: ${ID[$array]}"
					echo "     Server: ${server[$array]}"
					echo ""
					if echo $cutlistWithError | grep -q "${ID[$array]}"; then #Wenn Fehler gesetzt ist z.B. EPG-Error oder MissingBeginning
						echo -ne "${normal}"
					fi
				fi
				
				let tail++
				let cutlist_anzahl--
				let array++
				array1=array
			done

			if [ "$toprated" == "yes" ]; then # Wenn --toprated gesetzt wurde
				if [ "$angezeigt" == "" ]; then
					echo "Lade die Cutlist mit der besten User-Bewertung herunter."
					angezeigt=yes
				fi
				let array1--
				while [ $array1 -ge 0 ]; do
					rating1[$array1]=${rating[$array1]}	
					if [ "${rating1[$array1]}" == "" ]; then	#Wenn keine Benutzerwertung abgegeben wurde
						rating1[$array1]="0.00"			#Schreibe 0.00 als Bewertung
					fi
	      			rating1[$array1]=$(echo ${rating1[$array1]} | sed 's/\.//g')	#Entferne den Dezimalpunkt aus der Bewertung. 4.50 wird zu 450
	      			#echo "Rating ohne Komma: ${rating1[$array1]}"
	      			let array1--
	   			done

				numvalues=${#rating1[@]}	#Anzahl der Arrays

           			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%%??}	#Die beste Wertung ohne Dezimalpunkt
           			beste_bewertung_punkt=$beste_bewertung.${bigest##?}	#Die beste Wertung mit Dezimalpunkt

				if [ "$g" == "cutlist.de" ]; then
					bewertung_de=${beste_bewertung}
					bewertung_de_punkt=${beste_bewertung_punkt}
					let bewertung_de
				else
					bewertung_at=${beste_bewertung}
					bewertung_at_punkt=${beste_bewertung_punkt}
					let bewertung_at
				fi
			fi
		fi
	fi
done

if [ "$toprated" == "yes" ] && [ "$continue" == "0" ]; then
	bereits_toprated=no
	if ! echo $server | grep -q "cutlist.at"; then
		toprated_server=de
		beste_bewertung=${bewertung_de_punkt}
		echo "Die beste Bewertung ist: $beste_bewertung"
		echo "Server: de"
		bereits_toprated=yes	
	elif ! echo $server | grep -q "cutlist.de"; then
		toprated_server=at
		beste_bewertung=${bewertung_at_punkt}
		echo "Die beste Bewertung ist: $beste_bewertung"
		echo "Server: at"
		bereits_toprated=yes
	fi
	if [ "$bewertung_de" -gt "$bewertung_at" ] && [ "$bereits_toprated" == "no" ]; then
		toprated_server=de
		beste_bewertung=${bewertung_de_punkt}
		echo "Die beste Bewertung ist: $beste_bewertung"
		echo "Server: de"
	elif [ "$bewertung_at" -gt "$bewertung_de" ] && [ "$bereits_toprated" == "no" ]; then
		toprated_server=at
		beste_bewertung=${bewertung_at_punkt}
		echo "Die beste Bewertung ist: $beste_bewertung"
		echo "Server: at"
	fi
	if [ "$beste_bewertung" == "0.00" ]; then
		beste_bewertung=""
	fi
	if [ "$toprated_server" == "de" ]; then
		cutlist_nummer=$(grep "<rating>" "$tmp/cutlist.de" | grep -n "<rating>$beste_bewertung" | cut -d: -f1 | head -n1)
		id=$(grep "<id>" "$tmp/cutlist.de" | head -n$cutlist_nummer | tail -n1 | cut -d">" -f2 | cut -d"<" -f1) #ID der best bewertetsten Cutlist
		let num=$cutlist_nummer-1
		id_downloaded=$(echo ${ID[$num]})
		CUTLIST=$(grep "<name>" "$tmp/cutlist.de" | cut -d">" -f2 | cut -d"<" -f1 | head -n$cutlist_nummer | tail -n1 | tr -d "\r") #Name der Cutlist
		server_download="cutlist.de"
	else
		cutlist_nummer=$(grep "<rating>" "$tmp/cutlist.at" | grep -n "<rating>$beste_bewertung" | cut -d: -f1 | head -n1)
		id=$(grep "<id>" "$tmp/cutlist.at" | head -n$cutlist_nummer | tail -n1 | cut -d">" -f2 | cut -d"<" -f1) #ID der best bewertetsten Cutlist
		let num=$cutlist_nummer-1
		id_downloaded=$(echo ${ID[$num]})
		CUTLIST=$(grep "<name>" "$tmp/cutlist.at" | cut -d">" -f2 | cut -d"<" -f1 | head -n$cutlist_nummer | tail -n1 | tr -d "\r") #Name der Cutlist
		server_download="cutlist.at"
	fi
fi

if [ "$toprated" == "no" ] && [ "$continue" == "0" ]; then
	let array_groesse=$array
	let array_groesse--
	CUTLIST_ZAHL=""
	while [ "$CUTLIST_ZAHL" == "" ]; do #Wenn noch keine Cutlist gewählt wurde
		echo -n "Bitte die Nummer der zu verwendenden Cutlist eingeben: "
		read CUTLIST_ZAHL #Benutzereingabe lesen
		if [ "$CUTLIST_ZAHL" -gt "$array_groesse" ]; then
			echo -e "${gelb}Ungültige Auswahl.${normal}"
			CUTLIST_ZAHL=""
		fi
	done
	let array_groesse=$CUTLIST_ZAHL
	let CUTLIST_ZAHL++
	if [ "${server[$array_groesse]}" == "cutlist.de" ]; then
		id=$(grep "<id>" "$tmp/cutlist.de" | tail -n$CUTLIST_ZAHL | head -n1 | cut -d">" -f2 | cut -d"<" -f1)
		let num=$CUTLIST_ZAHL-1
		id_downloaded=$(echo ${id[$num]})
		CUTLIST=$(grep "<name>" "$tmp/cutlist.de" | tail -n$CUTLIST_ZAHL | head -n1 | cut -d">" -f2 | cut -d"<" -f1)
		server_download="cutlist.de"
	else
		id=$(grep "<id>" "$tmp/cutlist.at" | tail -n$CUTLIST_ZAHL | head -n1 | cut -d">" -f2 | cut -d"<" -f1)
		let num=$CUTLIST_ZAHL-1
		id_downloaded=$(echo ${id[$num]})
		CUTLIST=$(grep "<name>" "$tmp/cutlist.at" | tail -n$CUTLIST_ZAHL | head -n1 | cut -d">" -f2 | cut -d"<" -f1)
		server_download="cutlist.at"
	fi
fi

if [ "$continue" == "0" ]; then
	echo -n "Lade $CUTLIST von $server_download --> "
	#echo $id
	if [ "$server_download" == "cutlist.de" ]; then
		wget -q -O $tmp/$CUTLIST "http://cutlist.de/getfile.php?id=$id"
	else
		wget -q -O $tmp/$CUTLIST "http://cutlist.at/getfile.php?id=$id"
	fi
	test_cutlist #Testen der Cutlist
	if [ -f "$tmp/$CUTLIST" ] && [ "$cutlist_okay" == "yes" ]; then
		echo -e "${gruen}okay${normal}"
		continue=0
	else	
		echo -e "${rot}false${normal}"
		if [ "$HaltByErrors" == "yes" ]; then
			exit 1
		else
			continue=1
		fi
	fi
fi
}


#Hier wird überprüft um welches Cutlist-Format es sich handelt
function format ()
{
echo -n "Überprüfe um welches Format es sich handelt --> "
if cat $tmp/$CUTLIST | grep "StartFrame=" >> /dev/null; then
	echo -e "${blau}Frames${normal}"
	format=frames
elif cat $tmp/$CUTLIST | grep "Start=" >> /dev/null; then
	echo -e "${blau}Zeit${normal}"
	format=zeit
fi
 }

#Hier wir die Cutlist überprüft, auf z.B. EPGErrors, MissingEnding, MissingVideo, ...
function cutlist_error ()
{
#Diese Variable beinhaltet alle möglichen Fehler
errors="EPGError MissingBeginning MissingEnding MissingVideo MissingAudio OtherError"
for e in $errors; do
	error_check=$(cat $tmp/$CUTLIST | grep -m1 $e | cut -d"=" -f2 | tr -d "\r")
	if [ "$error_check" == "1" ]; then
		echo -e "${rot}Es wurde ein Fehler gefunden: \"$e\"${normal}"
		error_yes=$e
		if [ "$error_yes" == "OtherError" ]; then
			othererror=$(cat $tmp/$CUTLIST | grep "OtherErrorDescription")
			othererror=${othererror##*=}
			echo -e "${rot}Grund für \"OtherError\": \"$othererror\"${normal}"
		fi
		if [ "$error_yes" == "EPGError" ]; then
			epgerror=$(cat $tmp/$CUTLIST | grep "ActualContent")
			epgerror=${epgerror##*=}
			echo -e "${rot}ActualContent: $epgerror${end}"
		fi
		error_found=1
		cutlistWithError="${cutlistWithError} $id_downloaded"
		#echo $cutlistWithError
	fi
done
}

#Hier wird nun die Zeit ins richtige Format für avisplit umgerechnet
function time1 ()
{
time=""
let cut_anzahl=$(cat $tmp/$CUTLIST | grep "NoOfCuts" | cut -d"=" -f2 | tr -d "\r")
echo "####Auflistung der Cuts####"
if [ "$format" == "zeit" ]; then	#Wenn das verwendete Format "Zeit" ist
	let head1=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden."
	while [ "$cut_anzahl" -gt "0" ]; do
		#Die Sekunde in der der Cut beginnen soll
		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-)	#Die Sekunden umgerechned in das Format hh:mm:ss
		#Wie viele Sekunden der Cut dauert
		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	#Die Sekunde in der der Cut endet
		echo "Endcut: $time_seconds_ende. Sekunde"
		time=${time}$(date -u -d @$time_seconds_ende +%T,)	#Die Endsekunde im Format hh:mm:ss
		let head1++
		let cut_anzahl--
		#In der Variable $time sind alle Cuts wie folgt aufgelistet:
		#hh:mm:ss-hh:mm:ss,hh:mm:ss-hh:mm:ss,...
	done
elif [ "$format" == "frames" ]; then	#Wenn das verwendete Format "Frames" ist
	let head1=1
	echo "Es müssen $cut_anzahl Cuts umgerechnet werden."
	while [ $cut_anzahl -gt 0 ]; do
		#Der Frame bei dem der Cut beginnt
        	let startframe=$(cat $tmp/$CUTLIST | grep "StartFrame=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r")
          	echo "Startframe= $startframe"
          	time="${time}$startframe-"
		#Wie viele Frames dauert der Cut
          	let stopframe=$(cat $tmp/$CUTLIST | grep "DurationFrames=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r")
          	let stopframe=$stopframe+$startframe	#Der Frame bei dem der Cut endet
          	echo "Endframe= $stopframe"
          	time="${time}$stopframe,"	#Auflistung alles Cuts
          	let head1++
          	let cut_anzahl--
		#In der Variable $time sind alle Cuts wie folgt aufgelistet:
		#StartFrame-EndFrame,StartFrame-EndFrame,...
    	done
fi
echo "####ENDE####"
sleep 1
}

#Hier wird nun die Zeit ins richtige Format für avisplit umgerechnet, fals die date-Variante nicht funktioniert
function time2 ()
{
time=""
let cut_anzahl=$(cat $tmp/$CUTLIST | grep "NoOfCuts" | cut -d= -f2 | tr -d "\r")
echo "#####Auflistung der Cuts#####"
if [ $format == "zeit" ]; then
	let head1=1
   	echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
   	while [ $cut_anzahl -gt 0 ]; do
		#Die Sekunde in der der Cut startet
      		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	#Setze die Skunden auf $time_seconds_start
      		let mm=0	#Setze die Minuten auf 0
      		let hh=0	#Setze die Stunden auf 0
      		while [ $ss -ge "60" ]; do	#Wenn die Sekunden >= 60 sind
         		let mm++	#Zähle Minuten um 1 hoch
         		let ss=$ss-60	#Zähle Sekunden um 60 runter
         		while [ $mm -ge "60" ]; do	#Wenn die Minuten >= 60 sind
            			let hh++	#Zähle Stunden um 1 hoch
            			let mm=$mm-60	#Zähle Minuten um 60 runter
         		done
      		done
      		time2_start=$hh:$mm:$ss	#Bringe die Zeit ins richtige Format
      		echo "Startcut= $time2_start"
      		time="${time}${time2_start}-"	#Auflistung aller Zeiten
		#Sekunden wie lange der Cut dauert
      		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	#Die Sekunde in der der Cut endet
      		let ss=$time_seconds_ende	#Setze die Sekunden auf $time_seconds_ende
      		let mm=0	#Setze die Minuten auf 0
      		let hh=0	#Setze die Stunden auf 0
      		while [ $ss -ge "60" ]; do	#Wenn die Sekunden >= 60 sind
        		let mm++	#Zähle Minuten um 1 hoch
			let ss=$ss-60	#Zähle Sekunden um 60 runter
         		while [ $mm -ge "60" ]; do	#Wenn die Minuten >= 60 sind
            			let hh++	#Zähle Stunden um 1 hoch
            			let mm=$mm-60	#Z#hle Minuten um 60 runter
         		done
      		done
      		time2_ende=$hh:$mm:$ss	#Bringe die Zeit ins richtige Format
      		echo "Endcut= $time2_ende"
      		time="${time}${time2_ende},"	#Auflistung alles Zeiten
   	done
elif [ $format == "frames" ]; then
	let head1=1
    	echo "Es müssen $cut_anzahl Cuts umgerechnet werden"
    	while [ $cut_anzahl -gt 0 ]; do
		#Der Frame bei dem der Cut beginnt
		let startframe=$(cat $tmp/$CUTLIST | grep "StartFrame=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r")
          	echo "Startframe= $startframe"
          	time="${time}$startframe-"	#Auflistung der Cuts
		#Die Frames wie lange der Cut dauert
		let stopframe=$(cat $tmp/$CUTLIST | grep "DurationFrames=" | cut -d= -f2 | head -n$head1 | tail -n1 | tr -d "\r")
          	let stopframe=$stopframe+$startframe	#Der Frame bei dem der Cut endet
          	echo "Endframe= $stopframe"
          	time="${time}$stopframe,"	#Auflistung der Cuts
          	let head1++
          	let cut_anzahl--
    	done
fi
echo "#####ENDE#####"
sleep 1
}

#Hier wird nun, falls aviplit/avimerge gewählt wurde, avisplit und avimerge gestartet
function split ()
{
echo "Übergebe die Cuts an avisplit/avimerge"
avisplit -i $film -o "$outputfile" -t $time -c &&	#Hier wird avisplit gestartet, avimerge wird on-the-fly über den Parameter -c gestartet
if [ -f "$outputfile" ]; then
	echo -e "${gruen}$outputfile wurde erstellt${normal}"
	if [ "$delete" == "yes" ]; then
		echo "Lösche Quellvideo."
		rm -rf $i
	fi
else
	echo -e "${rot}Avisplit oder avimerge muss einen Fehler verursacht haben.${normal}"
	if [ "$HaltByErrors" == "yes" ]; then
		exit 1
	else
		continue=1
	fi
fi
}

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

//** Video **
// 01 videos source
app.load("$film")
//$cut_anzahl segments
app.clearSegments();
EOF
}
#Schreibe die Ausgabe von start in eine Datei
start >> $tmp/avidemux.js

let cut_anzahl=$(cat $tmp/$CUTLIST | grep "NoOfCuts" | cut -d= -f2 | tr -d "\r")
echo "#####Auflistung der Cuts#####"
if [ "$format" = "zeit" ]; 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" = "frames" ]; 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 [ "$verbose" == "yes" ]; then
	$CutProg --nogui --force-smart --run $tmp/avidemux.js --quit
elif [ "$verbose" == "no" ]; then
	$CutProg --nogui --force-smart --run $tmp/avidemux.js --quit >> /dev/null
fi

if [ -f $outputfile ]; then
	echo -n -e  ${gruen}$outputfile${normal}
     	echo -e "${gruen} wurde erstellt${normal}"
	if [ "$delete" == "yes" ]; then
		echo "Lösche Quellvideo."	
		rm -rf $i
	fi
else
     	echo -e "${rot}Avidemux muss einen Fehler verursacht haben${normal}"
     	if [ $HaltByErrors == "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_download" == "cutlist.at" ]; then
	echo ""
	echo "Sie können nun eine Bewertung 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:${normal}"
   		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://$server_download/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${normal}"	
      				echo -e " ${rot}Die Cutlist ist nicht von http://cutlist.de bzw. http://cutlist.at und kann nicht bewertet werden.${normal}"
	   		elif cat "$tmp/rate.php" | grep -q "Du hast schon eine Bewertung abgegeben oder Cutlist selbst hochgeladen."; then
	   		   	echo -e " ${rot}False${normal}"
	      			echo -e "${rot}Du hast für die Cutlist schonmal eine Bewertung abgegeben oder sie selbst hochgeladen.${normal}"
			elif cat "$tmp/rate.php" | grep -q "Sie haben diese Liste bereits bewertet"; then
	      			echo -e " ${rot}False${normal}"
	      			echo -e "${rot}Du hast für die Cutlist schonmal eine Bewertung abgegeben oder sie selbst hochgeladen.${normal}"
	   		elif cat "$tmp/rate.php" | grep -q "Cutlist wurde bewertet"; then
	      			echo -e "${gruen}Okay${normal}"
	      			echo -e "${gruen}Cutlist wurde bewertet${normal}"
	   		fi
   		else
	  	 	echo -e "${rot}False${normal}"
	   		echo -e "${rot}Bewertung fehlgeschlagen.${normal}"
   		fi
	fi
else
	echo -e "${gelb}Die Bewertungsfunktion steht momentan nur auf cutlist.at zur verfügung.${normal}"
fi
}

#Hier wird ein Otrkey-File dekodiert, falls es gewünscht ist
function decode ()
{
echo "Decodiere Datei --> "
$decoder -e $email -p $password -q -ow -i $i -o $tmp/
otrkey=$i
if [ "$delete" == "yes" ]; then
	echo "Lösche OtrKey"
	rm -rf $otrkey
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 Einstellung von \$tmp${normal}"
	exit 1
fi
echo "Lösche temporäre Dateien"
#echo $tmp
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.at als Server"
#elif [ "$server" == "2" ]; then
#   	echo "Verwende http://cutlist.mbod.net als Server"
#fi
software
	for i in $input; do
       		test
		del_tmp
		if [ "$decode" == "yes" ]; then
			decode
		fi
       		name
		if [ "$decode" == "yes" ]; then
			i=$tmp/$film_ohne_anfang
		fi
       	if [ "$UseLocalCutlist" == "yes" ]; then
           	local
       	fi
       	while true; do
      	 	if [ "$UseLocalCutlist" == "no" ] || [ "$vorhanden" == "no" ]; then
           		load
       		fi
       		if [ "$continue" == "0" ]; then
         	  	format
		fi
		if [ "$continue" == "0" ]; then
			cutlist_error
		fi
		if [ "$error_found" == "1" ] && [ "$toprated" == "no" ] && [ "$first" == "no" ]; then
			echo -e "${gelb}In der Cutlist wurde ein Fehler gefunden, soll sie verwendet werden? [y|n]${normal}"
			read error_antwort
			if [ "$error_antwort" == "y" ]; then
				echo -e "${gelb}Verwende die Cutlist trotz Fehler!${normal}"
				break
			else
				echo "Bitte neue Cutlist wählen!"
			fi
		else
			break
		fi
		if [ "$error_found" == "1" ] && [ "$toprated" == "yes" ] || [ "$first" == "yes" ]; then
			break
		fi
       	done
       	if [ "$CutProg" = "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!${normal}"
                 		if [ $HaltByErrors == "yes" ]; then
                    			exit 1
                 		else
                    			continue=1
                 		fi
              		fi
           	fi
           	if [ "$overwrite" == "yes" ]; then
              		split
           	fi
       	fi
       	if [ "$CutProg" = "avidemux" ] || [ "$CutProg" = "avidemux2" ] || [ "$CutProg" = "avidemux2_cli" ] || [ "$CutProg" = "avidemux2_qt4" ] || [ "$CutProg" = "avidemux2_gtk" ] && [ $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!${normal}"
                 		if [ $HaltByErrors == "yes" ]; then
                    			exit 1
                 		else
                    			continue=1
                 		fi
              		fi
           	fi
           	if [ "$overwrite" == "yes" ]; then
              		demux
           	fi
       	fi
       	if [ "$UseLocalCutlist" == "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
