#!/usr/bin/perl

use warnings ;
use strict ; #!!!
use locale ;
use File::Copy ;
use File::Basename ;
use Getopt::Long ;
use Time::localtime ;

### Konfiguration einlesen
my (  $glob , $Bitsizes ) = lese_config_Infos ( "$ENV{HOME}/.vdrtransxvid/vdrtransxvid.conf" ) ;
#my (  $glob , $Bitsizes ) = lese_config_Infos ( "./vdrtransxvid.conf" ) ;
# Bitsizes ist eine referenz auf  ein Arry von anonymen arrays mit jeweils 4 werten :
# mpa anz , DD anz , Minuten , Mbyte 
#  Viel spaß beim dereferenzieren ( ich hasse das ... )

my $BinDir = "/usr/bin/" ; # fix
my $MpgDir = $glob->{OutDir} ;

my $LastEdit="18.11.2007" ;
my $pid = $$ ;

## Strg-C abfangen
$SIG{INT} = \&quit ;

my $use = "mpg_to_avi_V4.pl Version $LastEdit

\$ mpg_to_avi_V4.pl [--auto][--showbatch][--dobatch]

Kommandozeilenparameter :
------------------------------------

-Erstellen einer der Infodatei für spätere Stapelverarbeitung
\$ mpg_2_avi_V4.pl --auto /FULLPATH/my_movie.mpg

optional eigene Zielgröße ( in Mbyte ) des Movies festlegen :
\$ mpg_2_avi_V4.pl --auto /FULLPATH/my_movie.mpg --size 300

optional Audiokompromierung abschalten ( default 1 ) :
\$ mpg_2_avi_V4.pl --auto /FULLPATH/my_movie.mpg --audio 0

- Zeige alle zur Stapelverarbeitung anstehenden Files : 
\$ mpg_2_avi_V4.pl --show

- Führe die Stapelverabeitung transcodieren durch :
\$ mpg_2_avi_V4.pl --do
" ;
my $WorkDir = GetHomeDir ()  ;
if ( ! -d "${WorkDir}${pid}" ) { mkdir "${WorkDir}${pid}" ; } # Unterverzeichnis mit pid anlegen
chdir "${WorkDir}${pid}/" ;
symlink "${WorkDir}/xvid4.cfg","${WorkDir}${pid}/xvid4.cfg" ;

if ( $#ARGV < 0 ) { print "$use" ; quit () ; }

## GetOpt::Long Hash Aufbau
my $dobatch = undef ;
my $showbatch = undef ;
my $InFile = undef ;
my $UserSize = undef ;
my $AudioNorm = 1 ;

GetOptions( 	"<>"		=> 	sub { print "$use" ; quit () ; } ,
			"do" 	=>	sub { &do_batch ; 
							cleanup () ;  
							quit () ; 
							} ,
			"show" 	=>	sub { &zeige_batch ;
							cleanup () ; 
							quit () ;
							}  ,
			"auto=s"	=>	\$InFile ,
			"size=i"	=>	\$UserSize ,
			"audio=i"	=>	\$AudioNorm , 
) ;
if ( $UserSize && ! $InFile ) {
				print "Option --size braucht generell die Option --auto ! Abruch ...\n" ;
				quit () ;
				}
if ( $InFile && -f $InFile ) { 
				&add_batch_no_interact ; 
				cleanup () ;
				quit () ;
				} 



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

sub add_batch_no_interact {
	my %Info ;

	( $Info{QuellSize} , $Info{QFile} , $Info{ZFile} ) = FileCheck ( $InFile ) ; ### QFile ist Infile mit durch _ ersetzen Leerzeichen
# debug
	print "\$Info{QuellSize} , \$Info{QFile} , \$Info{ZFile} : $Info{QuellSize} , $Info{QFile} , $Info{ZFile}\n" ;

	$Info{InfoDir} = ermittle_InfoDir ( $Info{ZFile} , $WorkDir ) ;
#debug 
	print "\$Info{InfoDir} : $Info{InfoDir}\n" ;

	$Info{Frames} = getframesall ($Info{QFile} , $Info{InfoDir} ) ;
#debug 
	print "\$Info{Frames} : $Info{Frames}\n" ;

#	print "$Info{QuellSize}\n$Info{QFile}\n$Info{ZFile}\n$Info{InfoDir}\n$Info{Frames}\n" ;

	$Info{Bereich} = "-c 1-$Info{Frames}" ; 
	$Info{GFrames} = $Info{Frames}  ;
# debug 
	print "\$Info{Bereich} \$Info{GFrames} : $Info{Bereich} , $Info{GFrames} \n" ;
	
	# audio dual  prüfen
	( $Info{Nr_audio_mpa} , $Info{Nr_audio_ac3} ) = &get_number_of_audio_sources ( $Info{QFile}  ) ;
	$Info{Size}  = get_Target_size ( $Info{GFrames} , $Info{Nr_audio_mpa} , $Info{Nr_audio_ac3} ) ;
	$Info{AudioNorm} = $AudioNorm ;
# debug 
	print "\$Info{Nr_audio_mpa} , \$Info{Nr_audio_ac3} \$Info{Size} \$Info{AudioNorm} : $Info{Nr_audio_mpa} , $Info{Nr_audio_ac3} $Info{Size} $Info{AudioNorm}\n" ;

#	$Info{Size}  = auto_filesize ( $Info{GFrames} , $Info{Nr_audio_mpa} , $Info{Nr_audio_ac3} ) ; 

#	Bugcatcher für Mythbusters-Die_Wissensjäger
#	if ( $Info{QFile}  =~ /Mythbusters-Die.Wissensjäger/ ) { $Info{Size} = 350 ;}

	$Info{Codec} = "xvid4" ; # gibt codec pur zurück
	( $Info{OBreite} , $Info{OHoehe} ) = AVPicSize ( $Info{QFile} ) ; # gibt die Originalausmaße eines Files zurück
	$Info{DivxRate} = Bitrateberech ( $Info{Size} , $glob->{Mp3} , $Info{GFrames} , $Info{Nr_audio_mpa} , $Info{Nr_audio_ac3} , $Info{QFile}  ) ;
#debug 
	print "\$Info{OBreite} , \$Info{OHoehe} \$Info{DivxRate} : $Info{OBreite} , $Info{OHoehe} $Info{DivxRate}\n" ;

#	print "$Info{Size}\n$Info{OBreite}\n$Info{OHoehe}\n$Info{DivxRate}\n" ;
	( $Info{Bildfaktor} , $Info{Show} ) = getAspect ( $Info{QuellSize} , $Info{QFile} ) ; # gibt Fliesskomma und print ala '16:9' zurück
	$Info{Stretch} = getstretch ( $Info{OBreite} , $Info{OHoehe} , $Info{Bildfaktor} ) ; # gibt stretch als FAktor,0,8 zurück
	( $Info{YCrop} , $Info{Deint} ) = deint_crop ( $Info{QFile} ,  $Info{Stretch} ) ; # viel subcode für : schwarze balken und deinterlace bestimmung
#debug 
	print "\$Info{Bildfaktor} , \$Info{Show} , \$Info{Stretch} , \$Info{YCrop} , \$Info{Deint} : $Info{Bildfaktor} , $Info{Show} , $Info{Stretch} , $Info{YCrop} , $Info{Deint}\n" ;  

	schreibe_Infos ( \%Info ) ; 
#
}


sub do_batch {
my @MpgList = glob "$glob->{OutDir}*mpg" ; # alle auf .mpg endenten files ins array
my @FileList ;
#print "@MpgList\n" ;
	foreach my $MpgListCont ( @MpgList ) {
		### Schnellbestimmung des mpeg namens
		my $Show = basename($MpgListCont) ;
		$Show =~ s/\.mpg// ;
		### batch erfassung ok und kein mpg2avi flag und mpg File existiert
		if ( -f "$glob->{Infodir}${Show}/mpg2avi.data" && ! -f "$glob->{Infodir}${Show}/mpg2avi_done" ) {
		push @FileList , "$glob->{Infodir}${Show}" ;  
		}
	}
	foreach my $temp ( @FileList ) {
		print "--> $temp\n" ;
			my $Info = lese_Infos ($temp) ;
#			foreach my $key ( keys %$Info ) {
#			print "$key = $Info->{$key}\n" ;		
#			}
		checkspace_for_avi ( $Info->{Size} ) ;

### debug part 
#if ( "$Info->{ZFile}" =~ /\/home\/alex\/Video_Bearbeitung_mpg\/Madagascar.avi/ ) {
		my $starttime = time () ;

		print "\n*INFO :\tEncoding startet jetzt mit 1. Durchgang...\n" ;
		Transcode1 ( $Info , $glob->{Debug_Level} , $glob->{QFact} ) ;


#	# RENDER IN SHORT iNFO TEXT ABOUT DUAL AUDIO AND / OR DD 5.1
		my $RenderText ;
		if ( exists $Info->{Nr_audio_mpa} and exists $Info->{Nr_audio_ac3} and $Info->{render_audio_infos} = "yes" ) {
			if ( "$Info->{Nr_audio_mpa}" gt 1 or  "$Info->{Nr_audio_ac3}" gt 0  and -f  "$Info->{InfoDir}audio.info" ) {
			open FH , "$Info->{InfoDir}audio.info" ;
			my $Audio_Info = <FH> ;
			close FH ;	
			$RenderText ="-J text=string=\"$Audio_Info\":font=\"$ENV{HOME}/.vdrtransxvid/Vera.ttf\":fade=2:range=25-225:posdef=6:points=12" ;
			}
			else { $RenderText = "" }
		}
		else { $RenderText = "" }
#		print "\$RenderText $RenderText\n" ;
	
		print "\n*INFO :\tEncoding startet jetzt mit 2. Durchgang...\n" ;
		Transcode2 ( $Info , $glob->{Mp3} , $glob->{QFact} , $RenderText ) ;
#
#	print "° $Info->{InfoDir}\n" ;
#	if ( -f "$Info->{InfoDir}dual_audio.flag" ) {
#	print "\n*INFO :\t2. Tonspur wird extrahiert , umgesetzt und wieder eingefügt...\n" ;
		if ( exists $Info->{Nr_audio_mpa} and exists $Info->{Nr_audio_ac3} ) {
			if ( "$Info->{Nr_audio_mpa}" gt 1 or  "$Info->{Nr_audio_ac3}" gt 0 ) {
			multilanguage ( $Info , $glob->{Mp3} , $glob->{QFact} ) ;
			}
		}
#}
		open my $FH , (">$Info->{InfoDir}mpg2avi_done") ;
		close $FH ;
		open  $FH , (">$Info->{InfoDir}avi2avi_done") ;
		close $FH ;
		my $endtime = time () ;
		my $time = $endtime - $starttime ;
#		print "--->\t$time sec\n" ;
		my $movietm = localtime ( $Info->{Frames} / 25 ) ;
		my $tm = localtime($endtime - $starttime) ;
		# ugly but i dont know why hour is one more , than needet
		my $movietm_hour = $movietm->hour - 1 ;
		my $tm_hour = $tm->hour -1 ;
# unlink sektion
		unlink "$Info->{QFile}" ;
		if ( $Info->{Nr_audio_ac3} eq 1 ) {
			( my $ac3_name = $Info->{QFile} ) =~ s/\.mpg/\.ac3/ ;
			unlink (dosh($ac3_name )) ;
		}

		printf ("-->\tAvi-Länge %02d:%02d:%02d Render-Zeit : %02d:%02d:%02d\n" , $movietm_hour , $movietm->min , $movietm->sec , $tm_hour , $tm->min , $tm->sec );
		print "\n" ;
	}

}

sub zeige_batch {
my @MpgList = glob "$glob->{OutDir}*mpg" ; # alle auf .mpg endenten files ins array
my @FileList ;
#print "@MpgList\n" ;
	foreach my $MpgListCont ( @MpgList ) {
		### Schnellbestimmung des mpeg namens
		( my  $InfoList = $MpgListCont ) =~ s/\.mpg// ;
		$InfoList = basename($InfoList) ;
		### batch erfassung ok und kein mpg2avi flag und mpg File existiert
		if ( -f "$glob->{Infodir}${InfoList}/mpg2avi.data" && ! -f "$glob->{Infodir}${InfoList}/mpg2avi_done" ) {
		open my $FH , "$glob->{Infodir}${InfoList}/mpg2avi.data" ;
		my ( $divx , $size , $ac3 , $mpa ) ;
			while ( <$FH> ) {
			chomp $_ ;
			$divx = ( split /\s=\s/ , $_ )[1] and $divx = "( $divx KBit/s )" if $_=~ /DivxRate/ ;
			$size = ( split /\s=\s/ , $_ )[1] and $size = "( $size MByte )" if $_=~ /Size/ ;
			$mpa = ( split /\s=\s/ , $_ )[1] and $mpa = "( Audio $mpa x )" if $_=~ /Nr_audio_mpa/ ;
			$ac3 = ( split /\s=\s/ , $_ )[1] and $ac3 = "( DD5.1 $ac3 )" if $_=~ /Nr_audio_ac3 = 1/ ;
			$ac3 = "" unless ( defined $ac3 ) ;			
			}	
		print "--> $InfoList $divx $size $mpa $ac3\n" ;  
		}
	}
}

#------------------------------------------------------------------------------
sub lese_config_Infos {
my $InfoDir = $_[0]  ;
my %Info ;
my @AnoSizeMatrize ;

	if ( -f "${InfoDir}" ) {
		open my $FH , "<${InfoDir}" ;
		while ( my $line = <$FH> ) { 
		next if ( $line =~ /^#/ or $line =~ /^\ *\n$/ ) ;
		chomp $line ;
		my ( $wert , $vallue ) ;
				if ( $line =~ /^\d+\s/ ) {
					my ( @AnoEinzelMatrize ) = $line =~ /^(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/  ;
					push @AnoSizeMatrize , \@AnoEinzelMatrize ;
				}
				elsif ( $line =~ /\s=\s/ ) {
					( $wert , $vallue ) = split ( " = " , $line ) ;
					$Info{$wert} = $vallue ;
					$wert =~ s/\ *$// ;
					$vallue =~ s/\ *$// ;
					$vallue =~ s/^\ *// ;
					$vallue =~ s/^\"// ;
					$vallue =~ s/\"$// ;
					$Info{$wert} = $vallue ;
#					print "$wert $Info{$wert}\n" ; 
				}
		}
		close $FH ;
	}
	else { print "File ${InfoDir} does not exist, not found, sorry ,ABORT\n" ; exit 1 ; }

return \%Info , \@AnoSizeMatrize ;
}

#------------------------------------------------------------------------------
sub GetHomeDir {
# returniert ${Home}/mpeg2avi"
my $Home=$ENV{'HOME'} ; # aus Umgebungsvariable Home Verzeichnis extrahieren
my $WorkDir="${Home}/mpeg2avi/" ;
if ( ! -d $WorkDir ) { mkdir $WorkDir } ; # Subdir Anlegen, wenn noch nicht existiert
return $WorkDir	;			# hineinwechseln
}
#------------------------------------------------------------------------------
sub cleanup {
unlink "divx4.log_mv" ; unlink "divx4.log" ;
}
#------------------------------------------------------------------------------
sub quit { print "\n*quit...\n" ; chdir "${WorkDir}" ; system ("rm -rf ${WorkDir}${pid}") ; exit 0 ; } 
#------------------------------------------------------------------------------
sub dosh {
my $in = $_[0] ;
$in =~ s/\s+/\ /g ; ## doppelte oder mehrere Leerzeichen auf eins reduzieren
$in =~ s/([\s \( \) \$ \& \§ \" \! \? \[  \] \' \,])/\\$1/g; # viele absonderliche Sonderzeichen für die shell qouten
$in =~ s/\\\\/\\/g ; # wenn ausdruck vorher schon geqotet war, die doppelten backslashes wieder auf einen kompenisieren
return $in ;
}
#------------------------------------------------------------------------------
sub FileCheck {
	my $FileDialog = $_[0]  ;
	my $QuellSize = ( -s $FileDialog ) / 1024 / 1024 ;
#	( my $QFile = $FileDialog ) =~ s/ /_/g  ; #alle Leerzeichen im Filenahmen durch _ ersetzen
	my $QFile = $FileDialog ;
	my $Beginn=rindex ( $QFile, ".") ;
	my $ZFile= substr ( $QFile ,0, $Beginn ) ;
	$ZFile="${ZFile}.avi";
	return $QuellSize , $QFile , $ZFile ; 
}
#------------------------------------------------------------------------------
sub ermittle_InfoDir {
my ( $InfoDir , $Home) = @_  ;
$InfoDir =~ s/\.avi// ;
$InfoDir =~ s/.*\/// ;
$InfoDir = "${Home}Info/${InfoDir}/" ;
unless ( -d "${InfoDir}" ) { mkdir "${InfoDir}" ; } ; ## anlegen wenn noch nicht existent
return $InfoDir ; 
}
#------------------------------------------------------------------------------
sub getframesall {
# bekommt $Info{QFile} , $Info{InfoDir} 
### ermittelt die Anzahl der Frames zu einem File
	my $QFile = dosh($_[0]) ;
	my $InfoDir = $_[1] ;
	my $Frames="undef" ; # immer erst undef setzen , da wenn nicht erster Durchlauf der Erfassung last if $Frames immer erfüllt !
	my $frames ;
#		print "\$QFile bei getframesall $QFile\n\$InfoDir bei getframesall $InfoDir\n" ;

# ${Home}mpeg2avi/Info/${$NameOut}/frames.dat ;
	if ( -f "${InfoDir}frames.dat" ) {
##y wenn ja, check ob file existiert
		open LOG , "${InfoDir}frames.dat" ;
			$Frames=<LOG> ;
			chomp $Frames ;
#	print "Frames aus ${InfoDir}frames.dat : $Frames\n" ; 
		close LOG ;
	}
	else {

		open TCS, "nice -n 2 $glob->{TcdemuxBin} -i $QFile -W 2>&1 1>/dev/null |" ;
		while ( my $Line = <TCS> ) {
	print "$Line" ;
			if ( $Line =~ /.*\ (\d+)\ .*video.*/ ) {
			$frames = $1 ; 
			} ;
		}
		close TCS  ;
		open LOG ,  ">${InfoDir}/frames.dat" ;
		print LOG "$frames\n" ;
		close LOG ;
		$Frames = $frames ;	
	}
	return $Frames ;
}
#------------------------------------------------------------------------------
sub get_number_of_audio_sources {
my $QFile = dosh($_[0]) ;
#		print "\$QFile bei get_number_of_audio_sources $QFile\n" ;
open TCS, "$glob->{TcprobeBin} -i $QFile 2>&1 |" ;
	my $i = 0 ;
	while ( my $Zeile = <TCS> ) {
	if ( $Zeile =~ /audio track: -a 0/ ) { $i++ }
	}
close TCS ;
### ac3 Part 
	my $j = 0 ;
	my $QFile_wo_dosh = $_[0] ;
	$QFile_wo_dosh =~ s/\.mpg// ;
	if ( -f "${QFile_wo_dosh}.ac3" ) { $j++ } 
return $i , $j ;
}
#------------------------------------------------------------------------------
######################## Ein Funktion zum Ermitteln der Zielgröße
sub get_Target_size {
	my $Frames = $_[0] ;
	my $Min = sprintf "%i" , $Frames / 60 / 25 ; 
	my $Nr_audio_mpa = $_[1] ;
	my $Nr_audio_ac3 = $_[2] ;
	my $NewSize = 0 ;
if ( $UserSize && $UserSize =~ /\d+/ ) { 
	print "INFO : $UserSize Mbyte bei $Frames Frames gesetzt\n" ; return $UserSize ;
}
foreach my $i (@{$Bitsizes} ) {
	next unless ( $i->[0] == $Nr_audio_mpa ) ;
	next unless ( $i->[1] == $Nr_audio_ac3 ) ;
	$NewSize = $i->[3] ;
	last if ( $Min <= $i->[2]) ; 
}
return $NewSize ;
}
#------------------------------------------------------------------------------
sub AVPicSize {
	my ( $OBreite , $OHoehe ) ;
	my $QFile = dosh($_[0]) ;
	open TRANSSIZE, "$glob->{TcprobeBin} -i $QFile 2>&1 |" ;
	while ( my $OutTrans = <TRANSSIZE> ) {
		if ( $OutTrans =~ /import frame size: -g (\d+)x(\d+) / ) { $OBreite=$1 ; $OHoehe=$2 ; } # Breit und Höhe feststellen
	}
	close TRANSSIZE ;
	return $OBreite , $OHoehe ;
}
#------------------------------------------------------------------------------
sub Bitrateberech {
	my ( $Size , $Mp3 , $GFrames , $Nr_audio_mpa  , $Nr_audio_ac3 , ${QFile} ) = @_  ;
	# Bugcatcher für dualaudio außerhalb der Auto Funktion
#	unless ( defined $dualaudio ) { $dualaudio = "single" ; }

	$Size = $Size + ( $Size / 55 ) ; ## orig statt 66 --> war 50 , bitte nochmal prüfen 02.09.2006

	my $AudioKbyte = sprintf ( "%.8f" , ( $Mp3 * $GFrames / 25 / 8 ) ) ; # ohne Overhead
	if ( $Nr_audio_mpa gt 1 ) { $AudioKbyte = $AudioKbyte * $Nr_audio_mpa  } ; 
#	print "\$AudioKbyte vor AC3 : $AudioKbyte\n" ;

#	print "\$AudioKbyte mpa : $AudioKbyte\n" ;
	my $AC3Size = 0 ;
	if ( $Nr_audio_ac3 gt 0  ) { 
		my $Ac3Name  = "${QFile}" ; 
#		print "$Ac3Name\n" ;
		$Ac3Name =~ s/\.mpg/\.ac3/ ;
#		print "$Ac3Name\n" ;
		$AC3Size = ( -s "$Ac3Name" ) / 1024  ;
		$AudioKbyte = $AudioKbyte + $AC3Size ;
	}
#	print "\$AudioKbyte nach AC3 : $AudioKbyte\n" ;
	my $CdSizeKbyte = sprintf ( "%.8f" , ( $Size * 1024 ) ) ;
	my $DivxRate = sprintf ( "%.0f" , ( ( $CdSizeKbyte - $AudioKbyte ) / $GFrames * 25 * 8 ) ) ; # ohne Overhead
	$DivxRate = 6000 if $DivxRate > 6000 ;
	if ( $DivxRate <= 700 ) {
		print "° Beta Code Warning ---> DivxRate lower than 700 Kbit/sec  ( $DivxRate Kbit/sec ) !!!!!
° Das wird nicht mehr gut aussehen, breche ab...\n" ;
		exit 1 ;
	}
	print "INFO : Divx Rate auf $DivxRate KBit/sec gesetzt\n" ;

#	print "\$AC3Size : $AC3Size\n\$AudioKbyte : $AudioKbyte\n\$CdSizeKbyte : $CdSizeKbyte\n" ;
	
	return $DivxRate ; 
}
#------------------------------------------------------------------------------
sub getAspect {
my ( $Bildfaktor , $Show ) ;
my ( $QuellSize , $QFile ) = @_  ;
$QFile = dosh($QFile) ;
#my $Deep= sprintf ( "%.i", $QuellSize / 20 ) ;
#open TCS, "$glob->{TcprobeBin} -i $QFile -H $Deep 2>&1 |" ;
open TCS, "$glob->{TcprobeBin} -i $QFile 2>&1 |" ;
	while ( my $Zeile = <TCS> ) {
	 my @ZeileSplit= split " ", $Zeile  ;
		if ( $ZeileSplit[0] =~ /aspect/ && $ZeileSplit[2] =~ /4:3/ ) {
		 $Bildfaktor = 4 / 3 ; $Show = "4:3" ;
		 }
			elsif ( $ZeileSplit[0] =~ /aspect/ && $ZeileSplit[2] =~ /16:9/ ) {
		 	$Bildfaktor = 16 / 9 ; $Show = "16:9" ;
			 }
				elsif ( $ZeileSplit[0] =~ /aspect/ && $ZeileSplit[2] =~ /1:1/ ) {
		 	$Bildfaktor = 16 / 9 ; $Show = "16:9" ;
			 }
	}
close TCS ;
return $Bildfaktor , $Show ;
}
#------------------------------------------------------------------------------
sub getstretch {
my ( $OBreite , $OHoehe , $Bildfaktor ) = @_ ;
# erklärende Berechnung :
# 704 x 576 4:3 orig Bildformatdaten
#576 * 1.3333333 # = 768
#704 / 768 * 576 # = 528 -> resultierende Höhe 4:3 bei 704 Breite
my $Hoehe4z3= int(( $OBreite / (  $OHoehe * $Bildfaktor ) ) *  $OHoehe )  ;
my $Stretch = int (( $OHoehe - $Hoehe4z3 ) / 8 ) ; # 8er blöcke
return "${Stretch},0,8" ;
}
#------------------------------------------------------------------------------
sub deint_crop {
#gibt zurück : $YCrop , $Deint
	my ( $QFile ,  $Stretch ) =@_ ; 
	$QFile = dosh($QFile) ;
	my ( $Deint , @VorDaten ) ;

# den File bis Frame 5750 durchlaufen
# ab 0 frames deinterlaced suchen
# ab 3500 frames detectclipping suchen
# alle Antwortzeilen in ein Array schaufeln
# dann Array nach den interessanten Dingen durchsuchen

	my @CropArr ;
	$| = 1 ; ## Schreibpuffer aussschalten
#	open CROP , "nice -n 5 $glob->{TranscodeBin} -i $QFile -M 3 -u 100,2  -y null -B ${Stretch},off,8 -J fieldanalysis=verbose,detectclipping=post:range=3500 -c 5750 --print_status 250 -o /dev/null 2>&1 |" ;
	open CROP , "nice -n 5 $glob->{TranscodeBin} -i $QFile -M 3 -u 100,2  -y null -B ${Stretch},off,8 -J fieldanalysis=verbose,detectclipping=post -c 10-3000 --print_status 250 -o /dev/null 2>&1 |" ;
	while ( my $CropZeile = <CROP> ) {
#	print "--> $CropZeile" ;
		chomp $CropZeile ;
		push @CropArr , $CropZeile  ;
	### part prozentanzeige
			if ( $CropZeile =~ /(\d+\.\d\%).*ETA:\ (\d+:\d+\:\d+)/ ) {
				print "\r" ;
				print "INFO : finde schwarze Balken / Halbild - Vollbilder ---> $1\tverbleibend : $2" ;
			}	
	}
	foreach  my $Crop ( @CropArr ) {
#	print "\$Crop : $Crop\n" ;
	### part deinterlace 
		if ( $Crop =~ /filter_fieldanalysis.so.*CONCLUSION: (.*) video.*$/ ) {
		my $deinterleace_word = "$1" ;
			if ( $deinterleace_word eq "interlaced" ) { $Deint="-I 5" ;  }
			elsif ( $deinterleace_word eq "progressive" ) { $Deint="-I off" ; }
		}
	### part detectclipping
		# $Crop : [detectclipping#0] valid area: X: 8..473 Y: 0..359  -> -Y 0,8,0,6
		if ( $Crop =~ /\[detectclipping\#0\].*-> -Y (\d+\,\d+\,\d+\,\d+)/ ) {
		my @RohDaten = split "," , $1 ;
			if ( $#VorDaten > 0 ) {
				my $Zaehl ;
				for ( $Zaehl = 0 ; $Zaehl <= 3 ; $Zaehl++ ){ 
					if ( $RohDaten[$Zaehl] < $VorDaten[$Zaehl] ) { $VorDaten[$Zaehl] = $RohDaten[$Zaehl] ; }
				}
			}
			else { @VorDaten = @RohDaten };
		}
	}
	$Deint = $Deint || "-I 5" ; ### wenn fieldanalysis scheitern sollte , default auf interleace setzten

### Bug workaround für interlaced "CSI"
#	if ( $QFile =~ /CSI.Den\ Tätern\ auf\ der\ Spur/ ) { $Deint="-I 5" ; }
	if ( $QFile =~ /Crossing\ Jordan/ ) { $Deint="-I 5" ; }


#dedectclipping : runden auf Vielfache von 8 --> mpeg4 encoder vorgabe
	my $Zaehl ;
	for ( $Zaehl = 0 ; $Zaehl <= 3 ; $Zaehl++ ) {
		$VorDaten[$Zaehl] = 8 * ( sprintf "%.0f" , ( $VorDaten[$Zaehl] / 8 ) ) ;
	}
# bei 16:9 : wenn logo oben und daher geringer clippingwert, wert von unten nehmen
	if ( $VorDaten[2] > $VorDaten[0] ) { $VorDaten[0] = $VorDaten[2] }

	my $YCrop="$VorDaten[0],$VorDaten[1],$VorDaten[2],$VorDaten[3]" ;
	close CROP ;
	$| = 0 ; ### Schreibpuffer wieder einschalten
	return $YCrop , $Deint ;
}
#------------------------------------------------------------------------------
sub schreibe_Infos {
my $Info = $_[0]  ;
print "\nINFO : Zusammenfassung :\n" ;
print "--------------------------------------------------------------------------------------------------\n" ;
		open my $fh , ">$Info->{InfoDir}/mpg2avi.data" ;
		foreach my $key ( sort ( keys %$Info ) ) {
			print  $fh "${key} = $Info->{$key}\n" ;
			if ( ${key} =~ /Bildfaktor|Codec|Deint|^Frames|Nr_audio_ac3|Nr_audio_mpa|Show|^Size|DivxRate/ ) {	
				print  "° ${key} = $Info->{$key}\n" ;
			}
		}
		close $fh ;
print "--------------------------------------------------------------------------------------------------\n" ;
}
#------------------------------------------------------------------------------
sub lese_Infos {
my $InfoDir = $_[0]  ;
my %Info ;
	if ( -f "${InfoDir}/mpg2avi.data" ) {
		open my $FH , "<${InfoDir}/mpg2avi.data" ;
		while ( my $line = <$FH> ) { 
		chomp $line ;
		my ( $wert , $vallue ) = split ( " = " , $line ) ;
		$Info{$wert} = $vallue ;
		}
		close $FH ;
	}
return \%Info ;
}
#------------------------------------------------------------------------------
sub multilanguage {
# if ( -f dual_audio.flag )
my ( $Info , $Mp3 , $QFact ) = @_ ;
my $QFile = dosh($Info->{QFile}) ;
my $ZFile = dosh($Info->{ZFile}) ;

	if ( $Info->{Nr_audio_mpa} eq 2 ) {
#		print "nice -n 5 $glob->{TranscodeBin} -i $Info->{QFile} -b ${Mp3},0,5,0 -u 200 -J normalize -x null,mpeg3  -y null,lame -a 1 -o $Info->{ZFile}.a1\n" ;
#		system ("nice -n 5 $glob->{TranscodeBin} -i $QFile $Info->{Bereich} -b ${Mp3},0,5,0 -u 200 -J normalize -x vob  -y raw -g 0x0  -a 1 -O -o ${ZFile}.a1") ;
		
		print "\n*INFO :\textrahiere 2. Tonspur aus mpg File\n" ;
		Parse_Transcode ("nice -n 5 $glob->{TranscodeBin} -i $QFile $Info->{Bereich} -b ${Mp3},0,5,0 -u 200 -J normalize -x vob  -y raw -g 0x0  -a 1 -O -o ${ZFile}.a1 --print_status 25 2>&1 |") ;

		print "--->\tFüge 2. Tonspur in Avi File ein" ;
		my $cool = `avimerge -i ${ZFile} -p ${ZFile}.a1 -o ${ZFile}.dual_audio 2>&1 1>/dev/null` and   print "  ...done\n" ; 
		unlink "$Info->{ZFile}.a1" ;
		unlink "$Info->{ZFile}" ;
		File::Copy::move "$Info->{ZFile}.dual_audio" , "$Info->{ZFile}" ;
	}
	if ( $Info->{Nr_audio_ac3} eq 1 ) {
		( my $ac3_name = $Info->{ZFile} ) =~ s/\.avi/\.ac3/ ;
		$ac3_name = dosh($ac3_name ) ;
		print "--->\tFüge 5.1 Ac3 File in Avi File ein" ;
		my $cool = `avimerge -i ${ZFile} -p $ac3_name -o ${ZFile}.ac3_audio 2>&1 1>/dev/null` and   print "  ...done\n" ;
#		unlink "$ac3_name" ;
		unlink "$Info->{ZFile}" ;
		File::Copy::move "$Info->{ZFile}.ac3_audio" , "$Info->{ZFile}" ;
	}
}
#------------------------------------------------------------------------------
sub checkspace_for_avi {
my $need_space = ( $_[0] * 1024 ) ;
	my @df = split " " , (`df $glob->{OutDir}`) ;
	if ( $df[10] <= ( $need_space ) ) {
		my $needet = sprintf ("%.i" , ( $need_space - $df[10] ) / 1024 ) ; 
		print "° Nicht genügend Platz in $glob->{OutDir}, bitte mind. $needet MBytes freimachen\n" ;
		&quit ;
	}
}
#################################################################
sub Transcode1 {
#my ( $QFile , $QFact , $DivxRate , $Stretch , $YCrop , $Deint , $Codec , $Bereich , $Debug_Level ) = @_  ;
my (  $Info , $Debug_Level , $QFact ) = @_  ;
my $QFile = dosh($Info->{QFile}) ;

#print "nice -n 5 /home/alex/compilate/transcode-1.0.0-bin/bin/transcode -i $Info->{QFile}  -M 3 ${QFact} -w $Info->{DivxRate},250,100  --divx_quant 1,30  -u 15 -B $Info->{Stretch} -Y $Info->{YCrop}  $Info->{Deint} -R 1 -y $Info->{Codec},null $Info->{Bereich} ${Debug_Level} --accel mmxext --print_status 25,0 -o  /dev/null 2>&1 |\n" ; 
#print "nice -n 15 $glob->{TranscodeBin} -i ${QFile}  -M 3 ${QFact} -w $Info->{DivxRate},250,100  -u 100,1 -B $Info->{Stretch} -Y $Info->{YCrop}  $Info->{Deint} -R 1 -y $Info->{Codec},null $Info->{Bereich} ${Debug_Level} --accel 3dnowext -o  /dev/null \n" ;

#$Info->{Bereich} = "-c 1-3000" ;
Parse_Transcode ("nice -n 15 $glob->{TranscodeBin} -i ${QFile}  -M 3 ${QFact} -w $Info->{DivxRate},250,100  -u 100,1 -B $Info->{Stretch} -Y $Info->{YCrop}  $Info->{Deint} -R 1 -y $Info->{Codec},null $Info->{Bereich} ${Debug_Level} --print_status 25 -o  /dev/null 2>&1 |" ) ;

#print "nice -n 15 $glob->{TranscodeBin} -i ${QFile}  -M 3 ${QFact} -w $Info->{DivxRate},250,100  -u 100,1 -B $Info->{Stretch} -Y $Info->{YCrop}  $Info->{Deint} -R 1 -y $Info->{Codec},null $Info->{Bereich} ${Debug_Level} -o  /dev/null \n" ;

#system ("nice -n 15 $glob->{TranscodeBin} -i ${QFile}  -M 3 ${QFact} -w $Info->{DivxRate},250,100  -u 100,1 -B $Info->{Stretch} -Y $Info->{YCrop}  $Info->{Deint} -R 1 -y $Info->{Codec},null $Info->{Bereich} ${Debug_Level} --accel 3dnowext  -o  /dev/null " ) ;
}
#  --accel mmxext  --accel 3dnowext
#------------------------------------------------------------------------------
sub Transcode2 {
#my ( $QFile , $QFact , $DivxRate , $Mp3 , $Stretch , $YCrop , $Deint , $Codec , $Bereich , $ZFile ) = @_ ;
my ( $Info , $Mp3 , $QFact , $RenderText ) = @_ ;
my $QFile = dosh($Info->{QFile}) ;
my $ZFile = dosh($Info->{ZFile}) ;
my $normalize ;
if ( $Info->{AudioNorm} == 1 ) { $normalize = "-J normalize" } 
else { $normalize = "" } ;

#print "\$normalize = $normalize\n" ;

#print "nice -n 5 /home/alex/compilate/transcode-1.0.0-bin/bin/transcode  -M 3 $QFact -i $Info->{QFile} -w $Info->{DivxRate},250,100 -divx_quant 1,30 -b ${Mp3},0,5,0  -u 15 -B $Info->{Stretch} -Y  $Info->{YCrop} -J normalize $Info->{Deint} -R 2  -y $Info->{Codec} $Info->{Bereich} --accel mmxext --print_status 25,0 -o  $Info->{ZFile}  2>&1 |\n" ;
#print "nice -n 15 $glob->{TranscodeBin}  -M 3 $QFact -i ${QFile} -w $Info->{DivxRate},250,100 -b ${Mp3},0,5,0  -u 100,1 -B $Info->{Stretch} -Y  $Info->{YCrop} -J normalize $RenderText $Info->{Deint} -R 2  -y $Info->{Codec} $Info->{Bereich} --avi_comments $glob->{OutDir}avi.comment  --accel 3dnowext -o  ${ZFile}\n" ;
#$Info->{Bereich} = "-c 1-3000" ;
Parse_Transcode ("nice -n 15 $glob->{TranscodeBin}  -M 3 $QFact -i ${QFile} -w $Info->{DivxRate},250,100 -b $glob->{Mp3},0,5,0  -u 100,1 -B $Info->{Stretch} -Y  $Info->{YCrop} -s 0.95 $normalize $RenderText $Info->{Deint} -R 2  -y $Info->{Codec} $Info->{Bereich}  --print_status 25 -o  ${ZFile} 2>&1 |") ;

#print "nice -n 15 $glob->{TranscodeBin}  -M 3 $QFact -i ${QFile} -w $Info->{DivxRate},250,100 -b ${Mp3},0,5,0  -u 100,1 -B $Info->{Stretch} -Y  $Info->{YCrop} -J normalize $RenderText $Info->{Deint} -R 2  -y $Info->{Codec} $Info->{Bereich} --avi_comments $glob->{OutDir}avi.comment  -o  ${ZFile}\n" ;


#system ("nice -n 15 $glob->{TranscodeBin}  -M 3 $QFact -i ${QFile} -w $Info->{DivxRate},250,100 -b ${Mp3},0,5,0  -u 100,1 -B $Info->{Stretch} -Y  $Info->{YCrop} -J normalize $RenderText $Info->{Deint} -R 2  -y $Info->{Codec} $Info->{Bereich} --accel 3dnowext -o  ${ZFile}") ;
#--av_fine_ms -40
}
#------------------------------------------------------------------------------
#-----------------------------------------------------------------------------------------######Parse Transcoding------------------------------#
sub Parse_Transcode {
$| = 1 ;
my $z=0 ;
my $x=0 ;

open TRANSCODE2 , $_[0] ;
my @FrameRateStat ;
	while ( my $TransZeile = <TRANSCODE2> ) {
# für Audio Einstellungen :
	if ( $TransZeile =~ /\[transcode\] A\:/ ) { 
		my @View = split " " , $TransZeile ;
		if ( $TransZeile =~ /import/ && $_[0] =~ /-R 2/ ) 	{ print  "--->\tImportformat Audio : $View[6] $View[7] $View[9] kbps\n" ; }
		if ( $TransZeile =~ /export/ && $_[0] =~ /-R 2/ ) 	{ print  "--->\tExportformat Audio : $View[6] $View[7] $View[9] kbps\n" ; }
		if ( $TransZeile =~ /AV shift / && $_[0] =~ /-R 2/ ) 	{ print  "--->\tSyncronisation : $View[5] msec\n\n" ; }
	}
# für Video Einstellungen :
	if ( $TransZeile =~ /\[transcode\] V\:/ ) { 
		my @View = split " " , $TransZeile ;
#		if ( $TransZeile =~ /import frame/ ) 		{ print  "--->\tImportformat Video : $View[5] $View[6] $View[7] $View[8] $View[9]\n" ; }
		if ( $TransZeile =~ /new aspect ratio/ ) 	{ print  "--->\tResizeformat Video : $View[6] $View[7] \n" ; }
		#[transcode] V: clip frame (->)  | 464x360
		if ( $TransZeile =~ /clip frame/ ) 		{ print  "--->\tExportformat Video : $View[6] \n" ; }
		if ( $TransZeile =~ /bits\/pixel/ ) 		{ print  "--->\tBit-Pixelverhältnis : $View[4] \n" ; }
	}
# für den Verlauf :
#encoding frame [5],  36.92 fps,  0.3%, ETA: 0:00:00, ( 0| 0| 0)
#print "$TransZeile" unless ( $TransZeile =~ /encoding frame/ ) ;
	if ( $TransZeile =~ /encoding frame/ ) {
		$z++ ;
		$x++ ;
		if ( $z==1 ) {
			printf "%-8.8s %-11.11s %-10.10s %-13.13s %-1.1s \n" , "| Frames" , "| Framerate" , "| Prozent" , "| verbl. Zeit", "|" ;
		}
		$TransZeile =~ s/,|\[|\]//g ;
		my @View = split " " , $TransZeile ;
		if ( $x == 20 ) { $x=0 ; push @FrameRateStat , $View[3] ; }
		print "\r" ;
		#1450 10.37 96.7% 0:00:04
		printf "%-8.8s %-11.11s %-10.10s %-13.13s %-1.1s" , "| $View[2] " , "| $View[3] " , "| $View[5] " , "| $View[7]" , "|" ;
	}
}
close TRANSCODE2 ;
print "\n" ;

my $Durchschnitt = 0 ;
foreach  ( @FrameRateStat ) {
	$Durchschnitt = $Durchschnitt + $_  ;
}
$Durchschnitt = $Durchschnitt / ( $#FrameRateStat +1 )  ;
printf "%s %.2f %s" , "--->\tFramerate %" , "$Durchschnitt" , "\n" ;
$| = 0 ;
} # END of  Parse_Transcode