R128 Lautheitsmesser

Simpel · 10. Februar 2018

Moin.

Aufgrund einer PM von AndyG im englischsprachigen AutoIt-Forum habe ich mich entschlossen für mein Projekt in das deutsche Forum zu wechseln. Ich möchte einen Lautheitsmesser (offline als auch im Stream) programmieren. Grundlage sind EBU Tech 3341 für Lautheit allgemein, EBU Tech 3342 für Berechnung Lautheitsrange und ITU-R BS.1770-4 als Basis von Tech 3341.

Einer meiner ersten Ansätze war dieser hier:

Code

#include <Array.au3>
#include <StringConstants.au3>
#include <FileConstants.au3>
Local $filename ; EBU-Test-Set: https://tech.ebu.ch/publications/ebu_loudness_test_set
;~ $filename = @ScriptDir & "\EBU-Test-Set\EBU-reference_listening_signal_pinknoise_500Hz_2kHz_R128.wav" ; 120 Sekunden
$filename = @ScriptDir & "\EBU-Test-Set\1kHz Sine -20 LUFS-16bit.wav" ; 20 Sek
;~ $filename = @ScriptDir & "\EBU-Test-Set\1kHz Sine -26 LUFS-16bit.wav" ; 20 Sek
;~ $filename = @ScriptDir & "\EBU-Test-Set\1kHz Sine -40 LUFS-16bit.wav" ; 20 Sek
;~ $filename = @ScriptDir & "\EBU-Test-Set\seq-3341-12-24bit.wav" ; Piepen 10 Sekunden
; Read out file "metadata"
Local $h = FileOpen($filename, $FO_BINARY) ; binary
If $h = -1 Then _ErrorMessage(@error, @extended, @ScriptLineNumber - 1, "Could not open wav-file.", True, $h, "$h") ; ausführlichere Fehler-Meldung
Local $sHeader = FileRead($h, 2000) ; 2000 Byte sollten für den Headerteil erstmal reichen
Local $iPosition_fmt = StringInStr($sHeader, "666D7420") ; hier wird die Position von "fmt " ("666D7420" in HEX) gesucht - definierter Teil des WAV-Headers
$iPosition_fmt = ($iPosition_fmt - 3) / 2 ; das Ergebnis wird in Position der Bytes gewandelt
FileSetPos($h, $iPosition_fmt + 10, 0)
Local $iChannels = Number(FileRead($h, 2)) ; fmt + 10, 2byte für Kanalanzahl
ConsoleWrite('CH: ' & $iChannels & " ")
Local $iSamples = Number(FileRead($h, 4)) ; direkt danach, 4byte für die Samplerate
ConsoleWrite('SR: ' & $iSamples & " ")
FileSetPos($h, $iPosition_fmt + 22, 0)
Local $iBitrate = Number(FileRead($h, 2)) ; fmt + 22, 2byte für die Bitrate
ConsoleWrite('BR: ' & $iBitrate & " ")
FileSetPos($h, $iPosition_fmt + 28, 0)
Local $iLengthDataBlock = Number(FileRead($h, 4)) ; fmt + 28, 4 byte aus denen später die Länge des Files berechnet werden
Local $i100msSampleCount = $iSamples / 10 ; Anzahl der Samples für 1/10 Sekunde - 100ms-Fenster - Verschiebung des 400ms-Fensters
Local $iNumberOfAll100msRuns = Floor($iLengthDataBlock / (($iBitrate / 8) * $i100msSampleCount * $iChannels)) ; Anzahl aller 100ms Proben bis das ganze File gescannt ist
ConsoleWrite("L: " & $iNumberOfAll100msRuns / 10 & "s " & $filename & @CRLF)
; Declare further variable
Local $iCounterOf100msRuns = 0 ; Zähler für jeden 100ms Durchgang
Local $s100msReadOut ; 100ms ausgelesene Bytes aus dem File
Local $a100msHexArray ; Array der 100ms Samples in Hex
Local $iInteger ; aktuell ausgelesenes Sample
Local $a100msInteger[0] ; Array aller Samples innerhalb eines 100ms-Fensters
Local $a400msInteger[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary
Local $s100IntegerFilterKette ; String aller K-gefilterten Samples innerhalb eines 100ms-Fensters
Local $xnK1_2, $xnK1_1, $ynK1_2, $ynK1, $ynK1_1, $xnK1 ; Variablen für K-Filter Stage 1 - x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2]
Local $xnK2_2, $xnK2_1, $ynK2_2, $ynK2, $ynK2_1, $xnK2 ; Variablen für K-Filter Stage 2 - x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2]
Local $iMeanSquare400ms ; Effektivwert aller 400ms-Samples
Global $g_aAllMomentaryDecibel[$iNumberOfAll100msRuns - 3] ; die ersten drei 100ms-Fenster ergeben noch keine 400ms-Fenster zusammen, so daß noch kein Momentary-Wert berechnet werden kann
Local $aActualMomentaryForAllChannel[0] ; enthält in Decibel den Effektivwert des aktuellen Momentary pro Kanal
; Start calculate all Momentary
Local $hTimerStart = TimerInit() ; Start Zeitnahme Ermittelung sämtlicher Momentary
ProgressOn("File-Scan - Length of file: " & $iNumberOfAll100msRuns / 10 & "s", "Please wait...", "", @DesktopWidth - 350, @DesktopHeight - 220) ; Progress während des Programmierens und Debuggings rechts unten in die Ecke um die _ArrayDisplays zu sehen
While 1
ProgressSet($iCounterOf100msRuns * 100 / $iNumberOfAll100msRuns, Floor($iCounterOf100msRuns * 100 / $iNumberOfAll100msRuns) & "%") ; Progress refreshen
$s100msReadOut = FileRead($h, ($iBitrate / 8) * $i100msSampleCount * $iChannels) ; nächste 100ms des Files auslesen - $iBitrate/8 ergibt die Bytes pro Sample - mal die Anzahl der Kanäle, da die interleaved, also immer im Wechsel kommen
If @extended < ($iBitrate / 8) * $i100msSampleCount * $iChannels Then ; wenn die Anzahl der ausgelesenen Bytes kleiner sind als für 100ms benötigt (das File ist also zu Ende)
ExitLoop ; kein kompletter 100ms Readout mehr möglich, deshalb Daten verwerfen (laut R128)
EndIf
$s100msReadOut = StringTrimLeft($s100msReadOut, 2) ; "0x" entfernen um die Regex nicht zu verwirren
$a100msHexArray = StringRegExp($s100msReadOut, "([\x00-\xff]{" & 2 * $iBitrate / 8 & "})", 3) ; sucht nach HEX-Werten 2 Zeichen pro Byte für Bitrate/8 Byte
;~ _ArrayDisplay($a100msHexArray,"Zeile " & @ScriptLineNumber)
For $i = 0 To $i100msSampleCount - 1 ; für jedes Sample innerhalb 100ms
For $j = 1 To 1;$iChannels - !!!!!!! nach Umbau von Arrays auf Variablen kann ich spontan erstmal nur einen Kanal berechnen, wenn dieser Part fertig ist, dann wird er pro Kanal dupliziert mit erweiterten Variablen
$iInteger = $a100msHexArray[$i] ; nächster HEX-Wert
$iInteger = _ChangeEndian($iInteger) ; aus LittleEndian BigEndian machen - AutoIt rechnet mit BigEndian-HEX
$iInteger = Number($iInteger) ; Integer daraus machen
$iInteger = _SignedInteger($iInteger, $iBitrate) ; Integer mit Vorzeichen daraus machen, da Audio Samples in positiven und negativen Werten in Samples gerechnet werden
; K-filter stage 1 - high shelving 1kHz +4dB
$xnK1_2 = $xnK1_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 1 rücken eins weiter in die Vergangenheit
$xnK1_1 = $xnK1
$ynK1_2 = $ynK1_1
$ynK1_1 = $ynK1
$xnK1 = $iInteger
$ynK1 = Int(1.53512485958697 * $xnK1 - 2.69169618940638 * $xnK1_1 + 1.19839281085285 * $xnK1_2 + 1.69065929318241 * $ynK1_1 - 0.73248077421585 * $ynK1_2) ; Koeffizienten für stage 1 hard gecoded und nicht als Variablen wegen Geschwindigkeit
; K-filter stage 2 - low cut 100Hz
$xnK2_2 = $xnK2_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 2 rücken eins weiter in die Vergangenheit
$xnK2_1 = $xnK2
$ynK2_2 = $ynK2_1
$ynK2_1 = $ynK2
$xnK2 = $ynK1
$ynK2 = Int($xnK2 - 2 * $xnK2_1 + $xnK2_2 + 1.99004745483398 * $ynK2_1 - 0.99007225036621 * $ynK2_2) ; Koeffizienten für stage 2 hard gecoded und nicht als Variablen wegen Geschwindigkeit
$s100IntegerFilterKette &= $ynK2 & "|" ; gefiltertes Sample an die Kette hängen mit | als Trenner
Next
Next
; after all Samples needed for 100ms
$s100IntegerFilterKette = StringTrimRight($s100IntegerFilterKette, 1) ; letztes | entfernen
$a100msInteger = StringSplit($s100IntegerFilterKette, "|", $STR_NOCOUNT) ; ein Array aus der 100ms-Kette machen ohne Index
;~ _ArrayDisplay($a100msInteger, "IntegerKette")
_ArrayDelete($a400msInteger, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msInteger, $a100msInteger) ; die aktuellen 100ms hinzufügen
;~ _ArrayDisplay($a400msInteger, "400ms")
$iMeanSquare400ms = 0 ; Effektiv-Wert resetten
If $iCounterOf100msRuns > 2 Then ; erst wenn die ersten 400ms voll sind (nach 3 Runden 100ms)
ReDim $aActualMomentaryForAllChannel[$iChannels] ; !!! bei Surround > 5.0 wird von folgender Kanalreihenfolge ausgegangen L, R, C, LFE, Ls, Rs - Broadcast-Standard EBU
For $i = 0 To $iChannels - 1 ; was passiert hier mit dem LFE, der nicht berechnet werden darf??????? ######################
If $i < 3 Then ; L R C
$aActualMomentaryForAllChannel[$i] = _Decibel(_MeanSquare($a400msInteger)) ; berechnet aus den gefilterten Samples den Effektivwert und rechnet das in Dezibel um
ElseIf $i = 3 And $iChannels > 5 Then ; LFE
; nothing
Else ; Ls Rs
$aActualMomentaryForAllChannel[$i] = _Decibel(_MeanSquare($a400msInteger) * 1.41) ; die Surrounds werden mit 1,5dB oder Faktor 1,41 lauter bewertet
EndIf
Next
;~ _ArrayDisplay($aActualMomentaryForAllChannel)
$iMeanSquare400ms = _AdditionDecibel($aActualMomentaryForAllChannel) ; Addition der Pegel aller Kanäle zu einem Wert
$g_aAllMomentaryDecibel[$iCounterOf100msRuns - 3] = $iMeanSquare400ms
EndIf
$iCounterOf100msRuns += 1 ; Anzahl der durchgelaufenen 100ms Berechnungen um 1 erhöhen
$s100IntegerFilterKette = "" ; Filterkette löschen
WEnd
FileClose($h) ; File wird nicht mehr gebraucht und geschlossen
ProgressOff()
ConsoleWrite("Timer: " & Round(TimerDiff($hTimerStart) / 1000) & @CRLF) ; dieses war der zeitkritische Bereich, da die meisten Berechnungen hier mit den Samples oder alle 100ms berechnet werden
_ArraySort($g_aAllMomentaryDecibel, 1) ; damit die niedrigen Werte unten liegen
_ArrayDisplay($g_aAllMomentaryDecibel, "All sorted")
Local $iTresholdAbsolut = -70 ; alle Momentary unter -70dBFS sollen verworfen werden
Local $iIndexTresholdAbsolut
For $i = 0 To UBound($g_aAllMomentaryDecibel) - 1
If $g_aAllMomentaryDecibel[$i] < $iTresholdAbsolut Then
$iIndexTresholdAbsolut = $i ; ermittelt den ArrayIndex, ab dem Momentary nur noch unter -70dBFS zu finden sind
ExitLoop
EndIf
Next
Local $iLoudnessAverage ; durchschnittliche Lautheit ohne alle Werte unter -70dBFS
Local $sRangeToDelete ; um im Array alle Werte unterhalb des Thresholds zu löschen
If IsNumber($iIndexTresholdAbsolut) Then
If $iIndexTresholdAbsolut = 0 Then ; alle Werte unter -70dBFS
$iLoudnessAverage = "-INFINITE"
Else
$sRangeToDelete = $iIndexTresholdAbsolut & "-" & UBound($g_aAllMomentaryDecibel) - 1 ; Range ab dem Index Threshold Absolut bis zum Ende des Arrays
ConsoleWrite("Delete Indicies Absolut: " & $sRangeToDelete & @CRLF)
_ArrayDelete($g_aAllMomentaryDecibel, $sRangeToDelete) ; alle Werte unter -70dBFS löschen
_ArrayDisplay($g_aAllMomentaryDecibel, "All minus -70")
$iLoudnessAverage = _AverageDecibel($g_aAllMomentaryDecibel) ; Mittelwert der aller Momentary in Dezibel ermitteln
$iLoudnessAverage = Round($iLoudnessAverage, 3) ; 3 Stellen nach dem Komma - bei Release nur noch 1 Stelle nach dem Komma
EndIf
Else ; nichts kleiner -70dBFS gefunden
$iLoudnessAverage = _AverageDecibel($g_aAllMomentaryDecibel)
$iLoudnessAverage = Round($iLoudnessAverage, 3)
EndIf
ConsoleWrite("LK Average: " & $iLoudnessAverage & @CRLF)
Local $iLoudnessIntegrated ; Lautheit Integrated
If IsNumber($iLoudnessAverage) Then
Local $iTresholdRelative = $iLoudnessAverage - 10 ; der Threshold für Integrated liegt 10dB unter dem Mittelwert - alle Werte darunter werden verworfen
Local $iIndexTresholdRelative
For $i = 0 To UBound($g_aAllMomentaryDecibel) - 1
If $g_aAllMomentaryDecibel[$i] < $iTresholdRelative Then ; ermittelt ArrayIndex, ab dem Momentary kleiner Relativ-Threshold
$iIndexTresholdRelative = $i
ExitLoop
EndIf
Next
If $iIndexTresholdRelative <> "" Then ; wenn Werte unterhalb des relativen Threshold gefunden werden
$sRangeToDelete = $iIndexTresholdRelative & "-" & UBound($g_aAllMomentaryDecibel) - 1 ; Range ab dem Index Threshold Relativ bis zum Ende des Arrays
ConsoleWrite("Delete Indicies Relative: " & $sRangeToDelete & @CRLF)
_ArrayDelete($g_aAllMomentaryDecibel, $sRangeToDelete) ; alle Werte unter Threshold Relativ löschen
_ArrayDisplay($g_aAllMomentaryDecibel, "All minus relative")
$iLoudnessIntegrated = _AverageDecibel($g_aAllMomentaryDecibel) ; Mittelwert aller restlichen Momentary in Dezibel ermitteln
$iLoudnessIntegrated = Round($iLoudnessIntegrated, 3) ; 3 Stellen nach dem Komma - bei Release nur noch 1 Stelle nach dem Komma
Else ; keine Werte unterhalb Threshold Relativ
$iLoudnessIntegrated = $iLoudnessAverage
EndIf
Else ; LK Average = "-INFINITE", also alle Samples unter -70dBFS
$iLoudnessIntegrated = $iLoudnessAverage
EndIf
ConsoleWrite("LK Integrated: " & $iLoudnessIntegrated & @CRLF)
Exit
#Region - Funcs
Func _MeanSquare(ByRef $aInteger)
Local $iNumerator ; Zähler
For $i = 0 To UBound($aInteger) - 1
$iNumerator += ($aInteger[$i] ^ 2) ; alle Samples erst quadrieren und dann addieren
Next
Local $iMeanSquare = Sqrt($iNumerator / UBound($aInteger)) ; alle quadrierten und addierten Samples durch die Anzahl Samples teilen und die Wurzel ziehen
Return $iMeanSquare
EndFunc ;==>_MeanSquare
Func _AdditionDecibel($aArray) ; math by http://personal.cityu.edu.hk/~bsapplec/manipula.htm - Addiert Dezibel
Local $iLog_1
For $i = 0 To UBound($aArray) - 1
$iLog_1 += (10 ^ ($aArray[$i] / 10))
Next
Local $iL_Addition = 10 * Log10($iLog_1)
Return $iL_Addition
EndFunc ;==>_AdditionDecibel
Func _AverageDecibel($aArray) ; math by http://personal.cityu.edu.hk/~bsapplec/manipula.htm - Errechnet den Mittelwert aus Dezibel-Werten
Local $iAnzahl = UBound($aArray)
Local $iLog_1
For $i = 0 To UBound($aArray) - 1
$iLog_1 += (10 ^ ($aArray[$i] / 10))
Next
$iLog_1 *= (1 / $iAnzahl)
Local $iL_Average = 10 * Log10($iLog_1)
Return $iL_Average
EndFunc ;==>_AverageDecibel
Func Log10($fNb) ; Funktion für Logarithmus zur Basis 10 - AutoIt hat nur einen Logarithmus zur Basis 2: Log()
Return Log($fNb) / Log(10)
EndFunc ;==>Log10
Func _Decibel($iInteger)
;~ Return Round(10 * Log10($iInteger / (2 ^ ($iBitrate - 1))), 3) - 0.691 ; <--- das soll der richtige Algorithmus sein laut EBU und ITU, aber der macht viel zuviel Ergebnis (die setzen ihn evtl. an anderer Stelle ein)
Return Round(20 * Log10($iInteger / (2 ^ ($iBitrate - 1))), 3) - 0.691 ; -0.691 ist ein LKFS-Korrektor laut EBU
EndFunc ;==>_Decibel
Func _SignedInteger($iInteger, $iBitrate)
If $iInteger > ((2 ^ ($iBitrate - 1)) - 1) Then ; wenn Wert größer als die Hälfte der gesamten Integer (dann sind es die negativen Samples
$iInteger = Number($iInteger - (2 ^ $iBitrate)) ; soll die untere Hälfte ein negatives Vorzeichen bekommen - ist wird sonst automatisch Unsigned Integer angenommen
Else
$iInteger = Number($iInteger)
EndIf
Return $iInteger
EndFunc ;==>_SignedInteger
Func _ChangeEndian($iHex)
Local $iChangedEndian
For $i = 1 To StringLen($iHex) / 2
$iChangedEndian &= StringRight($iHex, 2) ; die hinteren nach vorne setzen
$iHex = StringTrimRight($iHex, 2) ; vom ursprünglichen gesamten LittleEndian-Hex-wert die ersten beiden Stellen löschen
Next
Return "0x" & $iChangedEndian
EndFunc ;==>_ChangeEndian
Func _ErrorMessage($iError, $iExtended, $iScrpitLineNumber, $sMessage = "", $bForcedExit = False, $vVariable = 0, $sVariableName = "")
Local $iFlag = 262148
Local $sOutro = "Continue?"
If $bForcedExit Then
$iFlag = 262144
$sOutro = "Program exits!"
EndIf
Local $iMB = MsgBox($iFlag, "Error", $sMessage & @CRLF & @CRLF & 'Debug Line: ' & $iScrpitLineNumber & @CRLF & 'Error: ' & $iError & @CRLF & 'Extended: ' & $iExtended & @CRLF & 'Variable: ' & $sVariableName & @CRLF & 'Content: ' & $vVariable & @CRLF & @CRLF & $sOutro)
If $iMB = 7 Or $bForcedExit = True Then Exit
Return
EndFunc ;==>_ErrorMessage
#cs ; dieses war die ursprüngliche Funktion für K-Filter Stage 1 und 2 - da das Kopieren in eine Funktion aber relativ viel Zeit in Anspruch nimmt (und zwar für jedes einzelne Sample) wird diese Berechnung hard gecoded
Func _K_Filter_Stage_1($xn, $xn_1, $xn_2, $yn_1, $yn_2)
;Global Const $g_a1K1 = -1.69065929318241
;Global Const $g_a2K1 = 0.73248077421585
;Global Const $g_b0K1 = 1.53512485958697
;Global Const $g_b1K1 = -2.69169618940638
;Global Const $g_b2K1 = 1.19839281085285
;Local $yn = $g_b0K1 * $xn + $g_b1K1 * $xn_1 + $g_b2K1 * $xn_2 - $g_a1K1 * $yn_1 - $g_a2K1 * $yn_2
Local $yn = $g_b0K1 * $xn + $g_b1K1 * $xn_1 + $g_b2K1 * $xn_2 - $g_a1K1 * $yn_1 - $g_a2K1 * $yn_2
Return Int($yn)
EndFunc
Func _K_Filter_Stage_2($xn, $xn_1, $xn_2, $yn_1, $yn_2)
;Global Const $g_a1K2 = -1.99004745483398 ; -199004745483398 14 Nullen
;Global Const $g_a2K2 = 0.99007225036621 ; 14 Nullen
;Global Const $g_b0K2 = 1.0
;Global Const $g_b1K2 = -2.0
;Global Const $g_b2K2 = 1.0
Local $yn = $g_b0K2 * $xn + $g_b1K2 * $xn_1 + $g_b2K2 * $xn_2 - $g_a1K2 * $yn_1 - $g_a2K2 * $yn_2
;~ Local $yn = $xn - 2 * $xn_1 + $xn_2 + 199004745483398 * $yn_1 - 99007225036621 * $yn_2 / 1e28
Return Int($yn)
EndFunc
#ce
#EndRegion - Funcs

Alles anzeigen

In diesem Code fehlt noch die Berechnung für alle Kanäle größer 1 (wegen eines Umbau des Codes erstmal weggefallen). Es wird auch noch kein 3s-Fenster berechnet, daß nötig wäre für die Lautheitsrange. Auch TruePeak ist noch nicht programmiert. Das ist alles nachrangig, denn die Berechnung für 2-kanaliges Stereo (die aufwändiges K-Filter werden nämlich schon für alle Kanäle berechnet) dauert etwas mehr als doppelte Echtzeit. Das ist natürlich nicht akzeptabel.

Hat irgendwer Ideen, wie sich die Rechenzeit runter bekommen läßt? Richtig auswirken würden sich Verbesserungen des Codes erstmal nur zwischen While1 - Wend. Denn diese Schleife berechnet alle Samples des Files.

Was ich zur Geschwindigkeitsoptimierung bereits herausgefunden und zum größten Teil beherzigt habe ist:

- Schreiben und Lesen in Variablen geht deutlich schneller als in Arrays

- Funktionsaufrufe für "kleine" aber häufige Berechnungen fressen mehr Zeit als hart im Main-Skript gecoded

Gruß, Conrad

**Andy** · 11. Februar 2018

Hi,

zunächst würde ich, um all dieses Umgerechne/Hex/Array-Gedöns zu vermeiden, die WAV-Datei komplett in eine DllStruct einlesen.

Die Daten stehen somit im Speicher und können in Autoit per DllstructGetData() an ihrer jeweiligen Position ausgelesen werden.

Die eigentliche Berechnung innerhalb der beiden FOR/TO-Schleifen würde ich dann auslagern in entweder eine mit einer Compilersprache erstellten Dll oder direkt in Assemblercode.

Beides reduziert die Laufzeit innerhalb der Schleifen auf nahezu NULL Millisekunden. Gehe von einer Beschleunigung der Berechnung mit Faktor 1000 aus...

Bin zzt. unterwegs, aber in der kommenden Woche sollte ich ein erstes Script zusammengebastelt bekommen

Simpel · 12. Februar 2018

Moin Andy,

da bin ich ja sehr gespannt drauf. Die Wav-Datei komplett einzulesen hatte ich auch überlegt, aber wenn das Ding mal ne Stunde oder mehr lang ist plus max. 6-8 Kanäle hat habe ich Sorge, dass das den Speicher überfüllt.

Aber wie gesagt, ich freue mich auf Deine Ideen und bin gespannt, wie fix das werden kann.

Gruß, Conrad

**Andy** · 12. Februar 2018

Bin schon weitergekommen^^

Für das Ein-Kanal-Beispiel aus deinem Script habe ich heute Abend schon eine (schnelle(re)) Variante.

Generell sollte man aber überlegen, inwieweit eine "universale" Berechnung Sinn macht.

Simpel · 12. Februar 2018

Moin.

Ich habe über's Wochenende die verschiedenen Kanäle hinzufügen können:

Code

AutoIt#include <Array.au3>
#include <StringConstants.au3>
#include <FileConstants.au3>
Local $filename ; EBU-Test-Set: https://tech.ebu.ch/publications/ebu_loudness_test_set
$filename = @ScriptDir & "\EBU-Test-Set\1kHz Sine -20 LUFS-16bit.wav" ; 20 Sek
Local $h = FileOpen($filename, $FO_BINARY) ; binary
If $h = -1 Then _ErrorMessage(@error, @extended, @ScriptLineNumber - 1, "Could not open wav-file.", True, $h, "$h") ; ausführlichere Fehler-Meldung
Local $sHeader = FileRead($h, 2000) ; 2000 Byte sollten für den Headerteil erstmal reichen
Local $iPosition_fmt = StringInStr($sHeader, "666D7420") ; hier wird die Position von "fmt " ("666D7420" in HEX) gesucht - definierter Teil des WAV-Headers
$iPosition_fmt = ($iPosition_fmt - 3) / 2 ; das Ergebnis wird in Position der Bytes gewandelt
Local $iPosition_AudioStream = $iPosition_fmt + 44 ; für RIFF WAVE die Position des Starts der Audiodaten
If StringInStr($sHeader, "466169726C69676874") Then ; hier wird Fairlight in HEX gesucht, denn dann ist
ConsoleWrite("!Fairlight-File ")
$iPosition_AudioStream = $iPosition_fmt + 68 ; die Position des Starts der Audiodaten anders
EndIf
FileSetPos($h, $iPosition_fmt + 10, 0)
Local $iChannels = Number(FileRead($h, 2)) ; fmt + 10, 2byte für Kanalanzahl
ConsoleWrite('CH: ' & $iChannels & " ")
Local $iSamples = Number(FileRead($h, 4)) ; direkt danach, 4byte für die Samplerate
ConsoleWrite('SR: ' & $iSamples & " ")
FileSetPos($h, $iPosition_fmt + 22, 0)
Local $iBitrate = Number(FileRead($h, 2)) ; fmt + 22, 2byte für die Bitrate
ConsoleWrite('BR: ' & $iBitrate & " ")
FileSetPos($h, $iPosition_fmt + 28, 0)
Local $iLengthDataBlock = Number(FileRead($h, 4)) ; fmt + 28, 4 byte aus denen später die Länge des Files berechnet werden
Local $i100msSampleCount = $iSamples / 10 ; Anzahl der Samples für 1/10 Sekunde - 100ms-Fenster - Verschiebung des 400ms-Fensters
Local $iNumberOfAll100msRuns = Floor($iLengthDataBlock / (($iBitrate / 8) * $i100msSampleCount * $iChannels)) ; Anzahl aller 100ms Proben bis das ganze File gescannt ist
ConsoleWrite("L: " & $iNumberOfAll100msRuns / 10 & "s " & $filename)
; Declare further variable
Local $iCounterOf100msRuns = 0 ; Zähler für jeden 100ms Durchgang
Local $s100msReadOut ; 100ms ausgelesene Bytes aus dem File
Local $a100msHexArray ; Array der 100ms Samples in Hex
Local $iInteger ; aktuell ausgelesenes Sample
Local $a100msInteger[0] ; Array aller Samples innerhalb eines 100ms-Fensters
Local $a400msIntegerCh1[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary für Kanal 1
Local $a400msIntegerCh2[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary für Kanal 2
Local $a400msIntegerCh3[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary für Kanal 3
Local $a400msIntegerCh4[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary für Kanal 4
Local $a400msIntegerCh5[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary für Kanal 5
Local $a400msIntegerCh6[$i100msSampleCount * 4] ; Array aller Samples innerhalb des 400ms-Fenster für Lautheit Momentary für Kanal 6
Local $s100IntegerFilterKette; String aller K-gefilterten Samples innerhalb eines 100ms-Fensters
Local $xnK1_2, $xnK1_1, $ynK1_2, $ynK1, $ynK1_1, $xnK1 ; Variablen für K-Filter Stage 1 - x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2]
Local $xnK2_2, $xnK2_1, $ynK2_2, $ynK2, $ynK2_1, $xnK2 ; Variablen für K-Filter Stage 2 - x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2]
Local $iMeanSquare400ms ; Effektivwert aller 400ms-Samples
Global $g_aAllMomentaryDecibel[$iNumberOfAll100msRuns - 3] ; die ersten drei 100ms-Fenster ergeben noch keine 400ms-Fenster zusammen, so daß noch kein Momentary-Wert berechnet werden kann
Local $aActualMomentaryForAllChannel[$iChannels] ; enthält in Decibel den Effektivwert des aktuellen Momentary pro Kanal
; variables for channel order - this maybe can be user adaptable in further developments
Global $g_CHANNEL_LEFT = 1
Global $g_CHANNEL_RIGHT = 2
Global $g_CHANNEL_CENTER = 3
Global $g_CHANNEL_LFE = 4
Global $g_CHANNEL_LEFT_SURROUND = 5
Global $g_CHANNEL_RIGHT_SURROUND = 6
Local $iHex
Local $iChangedEndian
FileSetPos($h, $iPosition_AudioStream, 0)
Local $hTimerStart = TimerInit() ; Start Zeitnahme Ermittelung sämtlicher Momentary
ProgressOn("File-Scan - Length of file: " & $iNumberOfAll100msRuns / 10 & "s", "Please wait...", "", @DesktopWidth - 350, @DesktopHeight - 220) ; Progress während des Programmierens und Debuggings rechts unten in die Ecke um die _ArrayDisplays zu sehen
While 1
If Mod($iCounterOf100msRuns, 250) = 0 Then ConsoleWrite(@CRLF) ; nächste Zeile in der Konsolen-Ausgabe
ConsoleWrite(".") ; Fortschritt zeigen
ProgressSet($iCounterOf100msRuns * 100 / $iNumberOfAll100msRuns, Floor($iCounterOf100msRuns * 100 / $iNumberOfAll100msRuns) & "%") ; Progress refreshen
$s100msReadOut = FileRead($h, ($iBitrate / 8) * $i100msSampleCount * $iChannels) ; nächste 100ms des Files auslesen - $iBitrate/8 ergibt die Bytes pro Sample - mal die Anzahl der Kanäle, da die interleaved, also immer im Wechsel kommen
If @extended < ($iBitrate / 8) * $i100msSampleCount * $iChannels Then ; wenn die Anzahl der ausgelesenen Bytes kleiner sind als für 100ms benötigt (das File ist also zu Ende)
ExitLoop ; kein kompletter 100ms Readout mehr möglich, deshalb Daten verwerfen (laut R128)
EndIf
$s100msReadOut = StringTrimLeft($s100msReadOut, 2) ; "0x" entfernen um die Regex nicht zu verwirren
$a100msHexArray = StringRegExp($s100msReadOut, "([\x00-\xff]{" & 2 * $iBitrate / 8 & "})", 3) ; sucht nach HEX-Werten 2 Zeichen pro Byte für Bitrate/8 Byte
For $i = 1 To $iChannels
If $i = $g_CHANNEL_LFE Then
; do nothing
Else
$xnK1_2 = 0
$xnK1_1 = 0
$ynK1_2 = 0
$ynK1 = 0
$ynK1_1 = 0
$xnK1 = 0 ; Variablen für K-Filter Stage 1 - x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] leeren
$xnK2_2 = 0
$xnK2_1 = 0
$ynK2_2 = 0
$ynK2 = 0
$ynK2_1 = 0
$xnK2 = 0 ; Variablen für K-Filter Stage 2 - x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] leeren
For $j = 1 To $i100msSampleCount ; für jedes Sample innerhalb 100ms pro Kanal
$iInteger = $a100msHexArray[($j * $iChannels - ($iChannels - $i)) - 1] ; nächster HEX-Wert des Kanals
; make little endian to big endian
$iChangedEndian = ""
For $k = 1 To StringLen($iInteger) / 2
$iChangedEndian &= StringRight($iInteger, 2) ; die hinteren nach vorne setzen
$iInteger = StringTrimRight($iInteger, 2) ; vom ursprünglichen gesamten LittleEndian-Hex-wert die ersten beiden Stellen löschen
Next
$iInteger = "0x" & $iChangedEndian
$iInteger = Number($iInteger) ; Integer daraus machen
; make signed integer
If $iInteger > ((2 ^ ($iBitrate - 1)) - 1) Then ; wenn Wert größer als die Hälfte der gesamten Integer (dann sind es die negativen Samples)
$iInteger = Number($iInteger - (2 ^ $iBitrate)) ; soll die untere Hälfte ein negatives Vorzeichen bekommen - wird sonst automatisch Unsigned Integer angenommen
Else
$iInteger = Number($iInteger)
EndIf
;~ ConsoleWrite($iInteger & @CRLF)
; K-filter stage 1 - high shelving 1kHz +4dB
$xnK1_2 = $xnK1_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 1 rücken eins weiter in die Vergangenheit
$xnK1_1 = $xnK1
$ynK1_2 = $ynK1_1
$ynK1_1 = $ynK1
$xnK1 = $iInteger
$ynK1 = Int(1.53512485958697 * $xnK1 - 2.69169618940638 * $xnK1_1 + 1.19839281085285 * $xnK1_2 + 1.69065929318241 * $ynK1_1 - 0.73248077421585 * $ynK1_2) ; Koeffizienten für stage 1 hard gecoded und nicht als Variablen wegen Geschwindigkeit
; K-filter stage 2 - low cut 100Hz
$xnK2_2 = $xnK2_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 2 rücken eins weiter in die Vergangenheit
$xnK2_1 = $xnK2
$ynK2_2 = $ynK2_1
$ynK2_1 = $ynK2
$xnK2 = $ynK1
$ynK2 = Int($xnK2 - 2 * $xnK2_1 + $xnK2_2 + 1.99004745483398 * $ynK2_1 - 0.99007225036621 * $ynK2_2) ; Koeffizienten für stage 2 hard gecoded und nicht als Variablen wegen Geschwindigkeit
$s100IntegerFilterKette &= $ynK2 & "|" ; gefiltertes Sample an die Kette hängen mit | als Trenner
Next
; after all Samples needed for 100ms
$s100IntegerFilterKette = StringTrimRight($s100IntegerFilterKette, 1) ; letztes | entfernen
$a100msInteger = StringSplit($s100IntegerFilterKette, "|", $STR_NOCOUNT) ; ein Array aus der 100ms-Kette machen ohne Index
$s100IntegerFilterKette = "" ; Filterkette löschen
$iMeanSquare400ms = 0 ; Effektiv-Wert resetten
; fill up all 400ms-Arrays per channel
Switch $i
Case $g_CHANNEL_LEFT
_ArrayDelete($a400msIntegerCh1, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msIntegerCh1, $a100msInteger) ; die aktuellen 100ms hinzufügen
Case $g_CHANNEL_RIGHT
_ArrayDelete($a400msIntegerCh2, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msIntegerCh2, $a100msInteger) ; die aktuellen 100ms hinzufügen
Case $g_CHANNEL_CENTER
_ArrayDelete($a400msIntegerCh3, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msIntegerCh3, $a100msInteger) ; die aktuellen 100ms hinzufügen
Case $g_CHANNEL_LEFT_SURROUND
_ArrayDelete($a400msIntegerCh5, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msIntegerCh5, $a100msInteger) ; die aktuellen 100ms hinzufügen
Case $g_CHANNEL_RIGHT_SURROUND
_ArrayDelete($a400msIntegerCh6, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msIntegerCh6, $a100msInteger) ; die aktuellen 100ms hinzufügen
Case $g_CHANNEL_LFE
; aktuell nichts tun, denn LFE soll bisher nicht beachtet werden
EndSwitch
; calculate mean square in decibel
If $iCounterOf100msRuns > 2 Then ; erst wenn die ersten 400ms voll sind (nach 3 Runden 100ms)
Switch $i
Case $g_CHANNEL_LEFT
$aActualMomentaryForAllChannel[$i -1] = _Decibel(_MeanSquare($a400msIntegerCh1)) ; berechnet aus den gefilterten Samples den Effektivwert und rechnet das in Dezibel um
Case $g_CHANNEL_RIGHT
$aActualMomentaryForAllChannel[$i -1] = _Decibel(_MeanSquare($a400msIntegerCh2))
Case $g_CHANNEL_CENTER
$aActualMomentaryForAllChannel[$i -1] = _Decibel(_MeanSquare($a400msIntegerCh3))
Case $g_CHANNEL_LEFT_SURROUND
$aActualMomentaryForAllChannel[$i -1] = _Decibel(_MeanSquare($a400msIntegerCh5) * 1.41) ; die Surrounds werden mit 1,5dB oder Faktor 1,41 lauter bewertet
Case $g_CHANNEL_RIGHT_SURROUND
$aActualMomentaryForAllChannel[$i -1] = _Decibel(_MeanSquare($a400msIntegerCh6) * 1.41)
Case $g_CHANNEL_LFE
; aktuell nichts tun, denn LFE soll bisher nicht beachtet werden
EndSwitch
EndIf
EndIf
Next
; Addition of channel decibel
If $iCounterOf100msRuns > 2 Then ; erst wenn die ersten 400ms voll sind (nach 3 Runden 100ms)
$iMeanSquare400ms = _AdditionDecibel($aActualMomentaryForAllChannel) ; Addition der Pegel aller Kanäle zu einem Wert
;~ ConsoleWrite($iMeanSquare400ms & @CRLF)
$g_aAllMomentaryDecibel[$iCounterOf100msRuns - 3] = $iMeanSquare400ms
EndIf
$iCounterOf100msRuns += 1 ; Anzahl der durchgelaufenen 100ms Berechnungen um 1 erhöhen
WEnd
; file is read out and all Momentary are calculated
FileClose($h) ; File wird nicht mehr gebraucht und geschlossen
ProgressOff()
ConsoleWrite(" " & $iCounterOf100msRuns & @CRLF)
ConsoleWrite("Timer: " & Round(TimerDiff($hTimerStart) / 1000) & @CRLF) ; dieses war der zeitkritische Bereich, da die meisten Berechnungen hier mit den Samples oder alle 100ms berechnet werden
; delete last empty row
_ArraySort($g_aAllMomentaryDecibel, 1) ; damit die niedrigen Werte unten liegen
Local $aEmptyFields = _ArrayFindAll($g_aAllMomentaryDecibel, "") ; manchmal ist das letzte Feld leer
If Not @error Then
For $i = UBound($aEmptyFields) - 1 To 0 Step -1
_ArrayDelete($g_aAllMomentaryDecibel, $aEmptyFields[$i])
Next
EndIf
_ArrayDisplay($g_aAllMomentaryDecibel, "All sorted")
; AVERAGE MOMENTARY
Local $iTresholdAbsolut = -70 ; alle Momentary unter -70dBFS sollen verworfen werden
Local $iIndexTresholdAbsolut
For $i = 0 To UBound($g_aAllMomentaryDecibel) - 1
If $g_aAllMomentaryDecibel[$i] < $iTresholdAbsolut Then
$iIndexTresholdAbsolut = $i ; ermittelt den ArrayIndex, ab dem Momentary nur noch unter -70dBFS zu finden sind
ExitLoop
EndIf
Next
Local $iLoudnessAverage ; durchschnittliche Lautheit ohne alle Werte unter -70dBFS
Local $sRangeToDelete ; um im Array alle Werte unterhalb des Thresholds zu löschen
If IsNumber($iIndexTresholdAbsolut) Then
If $iIndexTresholdAbsolut = 0 Then ; alle Werte unter -70dBFS
$iLoudnessAverage = "-INFINITE"
Else
$sRangeToDelete = $iIndexTresholdAbsolut & "-" & UBound($g_aAllMomentaryDecibel) - 1 ; Range ab dem Index Threshold Absolut bis zum Ende des Arrays
ConsoleWrite("Delete Indicies Absolut: " & $sRangeToDelete & @CRLF)
_ArrayDelete($g_aAllMomentaryDecibel, $sRangeToDelete) ; alle Werte unter -70dBFS löschen
_ArrayDisplay($g_aAllMomentaryDecibel, "All minus -70")
$iLoudnessAverage = _AverageDecibel($g_aAllMomentaryDecibel) ; Mittelwert der aller Momentary in Dezibel ermitteln
$iLoudnessAverage = Round($iLoudnessAverage, 3) ; 3 Stellen nach dem Komma - bei Release nur noch 1 Stelle nach dem Komma
EndIf
Else ; nichts kleiner -70dBFS gefunden
$iLoudnessAverage = _AverageDecibel($g_aAllMomentaryDecibel)
$iLoudnessAverage = Round($iLoudnessAverage, 3)
EndIf
ConsoleWrite("LK Average: " & $iLoudnessAverage & @CRLF)
; INTEGRATED
Local $iLoudnessIntegrated ; Lautheit Integrated
If IsNumber($iLoudnessAverage) Then
Local $iTresholdRelative = $iLoudnessAverage - 10 ; der Threshold für Integrated liegt 10dB unter dem Mittelwert - alle Werte darunter werden verworfen
Local $iIndexTresholdRelative
For $i = 0 To UBound($g_aAllMomentaryDecibel) - 1
If $g_aAllMomentaryDecibel[$i] < $iTresholdRelative Then ; ermittelt ArrayIndex, ab dem Momentary kleiner Relativ-Threshold
$iIndexTresholdRelative = $i
ExitLoop
EndIf
Next
If $iIndexTresholdRelative <> "" Then ; wenn Werte unterhalb des relativen Threshold gefunden werden
$sRangeToDelete = $iIndexTresholdRelative & "-" & UBound($g_aAllMomentaryDecibel) - 1 ; Range ab dem Index Threshold Relativ bis zum Ende des Arrays
ConsoleWrite("Delete Indicies Relative: " & $sRangeToDelete & @CRLF)
_ArrayDelete($g_aAllMomentaryDecibel, $sRangeToDelete) ; alle Werte unter Threshold Relativ löschen
_ArrayDisplay($g_aAllMomentaryDecibel, "All minus relative")
$iLoudnessIntegrated = _AverageDecibel($g_aAllMomentaryDecibel) ; Mittelwert aller restlichen Momentary in Dezibel ermitteln
$iLoudnessIntegrated = Round($iLoudnessIntegrated, 3) ; 3 Stellen nach dem Komma - bei Release nur noch 1 Stelle nach dem Komma
Else ; keine Werte unterhalb Threshold Relativ
$iLoudnessIntegrated = $iLoudnessAverage
EndIf
Else ; LK Average = "-INFINITE", also alle Samples unter -70dBFS
$iLoudnessIntegrated = $iLoudnessAverage
EndIf
ConsoleWrite("LK Integrated: " & $iLoudnessIntegrated & @CRLF)
Exit
; ############################################################
Func _MeanSquare(ByRef $aInteger)
Local $iNumerator ; Zähler
For $i = 0 To UBound($aInteger) - 1
$iNumerator += ($aInteger[$i] ^ 2) ; alle Samples erst quadrieren und dann addieren
Next
Local $iMeanSquare = Sqrt($iNumerator / UBound($aInteger)) ; alle quadrierten und addierten Samples durch die Anzahl Samples teilen und die Wurzel ziehen
Return $iMeanSquare
EndFunc ;==>_MeanSquare
Func _AdditionDecibel($aArray) ; math by http://personal.cityu.edu.hk/~bsapplec/manipula.htm - Addiert Dezibel
If UBound($aArray) >= $g_CHANNEL_LFE Then
_ArrayDelete($aArray, ($g_CHANNEL_LFE - 1))
EndIf
;~ _ArrayDisplay($aArray)
Local $iLog_1
For $i = 0 To UBound($aArray) - 1
$iLog_1 += (10 ^ ($aArray[$i] / 10))
Next
Local $iL_Addition = 10 * Log10($iLog_1)
Return $iL_Addition
EndFunc ;==>_AdditionDecibel
Func _AverageDecibel($aArray) ; math by http://personal.cityu.edu.hk/~bsapplec/manipula.htm - Errechnet den Mittelwert aus Dezibel-Werten
Local $iAnzahl = UBound($aArray)
Local $iLog_1
For $i = 0 To UBound($aArray) - 1
$iLog_1 += (10 ^ ($aArray[$i] / 10))
Next
$iLog_1 *= (1 / $iAnzahl)
Local $iL_Average = 10 * Log10($iLog_1)
Return $iL_Average
EndFunc ;==>_AverageDecibel
Func Log10($fNb) ; Funktion für Logarithmus zur Basis 10 - AutoIt hat nur einen Logarithmus zur Basis 2: Log()
Return Log($fNb) / Log(10)
EndFunc ;==>Log10
Func _Decibel($iInteger)
;~ Return Round(10 * Log10($iInteger / (2 ^ ($iBitrate - 1))), 3) - 0.691 ; <--- das soll der richtige Algorithmus sein laut EBU und ITU, aber der macht viel zuviel Ergebnis (die setzen ihn evtl. an anderer Stelle ein)
Return Round(20 * Log10($iInteger / (2 ^ ($iBitrate - 1))), 3) - 0.691 ; -0.691 ist ein LKFS-Korrektor laut EBU
EndFunc ;==>_Decibel
Func _ErrorMessage($iError, $iExtended, $iScrpitLineNumber, $sMessage = "", $bForcedExit = False, $vVariable = 0, $sVariableName = "")
Local $iFlag = 262148
Local $sOutro = "Continue?"
If $bForcedExit Then
$iFlag = 262144
$sOutro = "Program exits!"
EndIf
Local $iMB = MsgBox($iFlag, "Error", $sMessage & @CRLF & @CRLF & 'Debug Line: ' & $iScrpitLineNumber & @CRLF & 'Error: ' & $iError & @CRLF & 'Extended: ' & $iExtended & @CRLF & 'Variable: ' & $sVariableName & @CRLF & 'Content: ' & $vVariable & @CRLF & @CRLF & $sOutro)
If $iMB = 7 Or $bForcedExit = True Then Exit
Return
EndFunc ;==>_ErrorMessage

Alles anzeigen

Es gibt noch etwas, was man vielleicht generell mit bedenken sollte. Für die Berechnung der Lautheitsrange braucht man aus den 100ms-Momentary-Werten auch ein 3s-Fenster (und nicht nur das 400ms-Fenster für Integrated). Die Daten dürfen also nicht wieder zu früh entlassen werden, sondern auch das 3s-Fenster füllen.

Was meinst Du mit der universalen Berechnung?

Gruß, Conrad

Simpel · 12. Februar 2018

Wow,

da bin ich mit diesem doch noch halbwegs übersichtlichen Code über die 20.000 Zeichen Beschränkung gekommen? Habe ordentlich was löschen müssen (Kommentarzeilen und Leerzeilen für die Übersichtlichkeit). In Word werden die Zeichen wohl anders gezählt, denn da war ich mit dem Original-Code knapp unter 20.000 - hier wurde es aber nicht akzeptiert.

Gruß, Conrad

**Bitnugger** · 12. Februar 2018

Die Textcodierung hier im Forum ist UTF-8... und da wird es wohl so sein, dass die Anzahl der Bytes und nicht die Zeichen bzw. Glyphen gezählt werden, die übrigens bis zu 4 Byte verschlingen können.

Simpel · 12. Februar 2018

Ach ja, das könnte Sinn ergeben.

**Andy** · 12. Februar 2018

Sodele, komme gerade erst dazu, bissl zu programmieren.

Man müsste mal testen, inwieweit der "float" Datentyp für die Berechnung ausreicht. 8 Stellen Genauigkeit sollten ggf hinhauen. Dann könnte man die Berechnung in den SSE-Registern abhandeln, der gesamte Block

Code

$xnK1_2 = $xnK1_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 1 rücken eins weiter in die Vergangenheit
$xnK1_1 = $xnK1
$ynK1_2 = $ynK1_1
$ynK1_1 = $ynK1
$xnK1 = $iInteger
$ynK1 = Int(1.53512485958697 * $xnK1 - 2.69169618940638 * $xnK1_1 + 1.19839281085285 * $xnK1_2 + 1.69065929318241 * $ynK1_1 - 0.73248077421585 * $ynK1_2) ; Koeffizienten für stage 1 hard gecoded und nicht als Variablen wegen Geschwindigkeit
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $ynK1 = ' & $ynK1 & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
; K-filter stage 2 - low cut 100Hz
$xnK2_2 = $xnK2_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 2 rücken eins weiter in die Vergangenheit
$xnK2_1 = $xnK2
$ynK2_2 = $ynK2_1
$ynK2_1 = $ynK2
$xnK2 = $ynK1
$ynK2 = Int($xnK2 - 2 * $xnK2_1 + $xnK2_2 + 1.99004745483398 * $ynK2_1 - 0.99007225036621 * $ynK2_2) ; Koeffizienten für stage 2 hard gecoded und nicht als Variablen wegen Geschwindigkeit

Alles anzeigen

wäre dann in nicht mal 10 Prozessortakten abgewatscht, und nur in einer Handvoll Zeilen ASM-Code. Auf neueren Prozessoren könnte man sogar ein FMA (fused multiply add) verwenden, also a=b+c*d und das mit 4 Registerinhalten gleichzeitig, d.h. die gesamte Zeile

Code

(1.53512485958697 * $xnK1 - 2.69169618940638 * $xnK1_1 + 1.19839281085285 * $xnK1_2 + 1.69065929318241 * $ynK1_1 - 0.73248077421585 * $ynK1_2)

wäre mit einem (!) Prozessorbefehl abgehandelt....schaumamal

Sollte die Genauigkeit höher sein müssen, dann muss man double verwenden, da kann man immer noch die SSE-Register verwenden. Leider passen da dort in die 128 Bit nur 2xdouble (64Bit) Zahlen rein, aber besser wie nix. Immer noch Welten schneller als die gängigen Compiler mit FPU-Code :o)

Simpel · 12. Februar 2018

Also theoretisch könnten die Audiosamples signed Integer 32bit sein. Ich durchdenke aber auch gerade, ob man allen Audiosamples größer 16bit einfach die lower Bytes klaut und 16bit draus macht. Das könnte eine Ungenauigkeit in der Größe des letzten 16bit-Bits sein, vermute ich, aber es ist, glaube ich, genau genug. Die Lautheitswerte werden am Ende mit einer Dezimalstelle angegeben. Ich muss das mal konkret durchrechnen.

Ob 8 Nachkommastellen für die Filterberechnung reicht, muß ich auch ausprobieren.

Gruß, Conrad

**Andy** · 18. Februar 2018

Hi!

Zitat von Simpel

Also theoretisch könnten die Audiosamples signed Integer 32bit sein. Ich durchdenke aber auch gerade, ob man allen Audiosamples größer 16bit einfach die lower Bytes klaut und 16bit draus macht. Das könnte eine Ungenauigkeit in der Größe des letzten 16bit-Bits sein, vermute ich, aber es ist, glaube ich, genau genug. Die Lautheitswerte werden am Ende mit einer Dezimalstelle angegeben. Ich muss das mal konkret durchrechnen.

Ob 8 Nachkommastellen für die Filterberechnung reicht, muß ich auch ausprobieren.

Daran bin ich in den letzten Stunden gescheitert...

Nachdem ich die Berechnungen nach Assembler (die SSE-Register beinhalten 4xfloat und werden parallel in einem Takt(!) berechnet) überführt hatte, und für die ersten (hunderte bis tausende) Schleifendurchläufe exakt auf die gleichen (Integer)Werte kam, musste ich dennoch feststellen, dass es mitten in der Berechnung zu einer immer größeren "Drift" der Ergebnisse kam. Letztendlich liegt es an der Konstanten 1.99004745483398, für die es KEINE Entsprechung als float gibt.

Für die Berechnung würde benötigt ein Wert von float 1.9900474 (man beachte die letzte Stelle hinter dem Komma, also die 4), aber DEN GIBT ES NICHT!

Wen das näher interessiert, der sei hierhin verwiesen!

Das letzte Bit in der Mantisse wechselt zwischen 1.9900473 und 1.9900475, und exakt dieses eine (fehlende "halbe" ) Bit führt zu unterschiedlichen Ergebnissen, da sich innerhalb der Schleife der "Fehler" in den hunderten Multiplikationen immer weiter fortsetzt.

Float hat eine Genauigkeit von 8 Stellen incl. Vorkomma, d.h. bei vier Vorkommastellen bleiben nur 4 Nachkommastellen für die Genauigkeit übrig und da summieren sich dann bei Multiplikationen mit großen Zahlen die "Fehler" gegenüber AutoIt, welches intern mit double, also 64Bit Genauigkeit rechnet.

Man könnte natürlich in Assembler auch mit double rechnen und die seit 40 Jahren unveränderte FPU im Prozessor bemühen (genau wie das AutoIt bzw. die davon aufgerufenen Funktionen des M$-C++-Compilers machen), das wäre geschätzt Faktor 20 langsamer als der entsprechende SSE-Code für double, aber das war ja nicht die Intention. Nur mal für die Galerie, den Abschnitt

Code

$xnK1_2 = $xnK1_1 ; die Werte für x[n], x[n-1], x[n-2], y[n], y[n-1], y[n-2] stage 1 rücken eins weiter in die Vergangenheit
$xnK1_1 = $xnK1
$ynK1_2 = $ynK1_1
$ynK1_1 = $ynK1
$xnK1 = $iInteger

wickelt der Assemblercode in 3 Prozessortakten ab (4x floatwert in einem Register einen Platz nach links shiften und den (vorher in float umgewandelten) Integer einfügen) .

Die Zeile

$ynK1 = Int(1.53512485958697 * $xnK1 - 2.69169618940638 * $xnK1_1 + 1.19839281085285 * $xnK1_2 + 1.69065929318241 * $ynK1_1 - 0.73248077421585 * $ynK1_2)

wird in 12 Takten abgewickelt, davon entfallen allein 8 Takte auf die Umwandlung von float nach int und wieder nach float. Prozessor- bzw. Registerintern wird nur mit float gerechnet!

Der Gesamtfehler im Vergleich double zu float bewegt sich bei ca. 1-2%. Leider gibt es auch seltene Ausreißer, bei denen es einen Fehler von 25% gibt. Ob du damit leben kannst, musst du herausfinden.

Den Faktor 1000 als Geschwindigkeitsvorteil (für die Berechnungen innerhalb der Schleife) habe ich nicht ganz erreicht, aber Faktor 600 ist auch nicht schlecht^^

Im 64-Bit-Modus hätte ich YMM-Register (256Bit) verwenden können, das wäre etwas aufwendiger geworden, hätte aber die Berechnungen massiv beschleunigt, weil KEIN(!) Speicherzugriff zum Abspeichern der Zwischenergebnisse nötig gewesen wäre!

Generell ist dein Ansatz aus der Sicht eines AutoIt-Programmierers (ich sag es mal vorsichtig, nicht falsch verstehen!) "grenzwertig".

Einen String aus Zahlen zu erstellen, aus dem dann ein Array gemacht wird, welches wiederum "beschnitten" und ergänzt und letztendlich noch sortiert wird, ist extrem suboptimal.

Aber dafür kannst du eigentlich wenig, die Beschränkung liegt eher in der generell langsamen (Berechnungs-)Geschwindigkeit von AutoIt aber hauptsächlich in der Behandlung von Arrays.

Die Daten in der Audio-Datei liegen doch sowieso schon als "Array" vor, ich habe diese einfach ausgelesen und per BinaryToString() in eine Struct aus 16-Bit-integer geschrieben. Keine weitere "Umrechnung" nötig!

Schreibst du das Script statt "Arrays" auf eine DllStruct() um, dann sparst du dir sämtliche Umrechnungen aus String nach Array, das ArrayDelete/Add (wird ersetzt durch ein ultraschnelles Memcopy).

Für einen Compiler mit einem 16-Bit-Array im Sourcecode wäre das ein gefundenes Fressen. Das komplette Script (und nicht nur die einzelne (Schleifenberechnung!) wäre in einigen Millisekunden abgehandelt, also ECHTZEIT!

Und da wäre seitens Optimierung noch reichlich Luft nach oben!

Versuch mal, dein Script einem Basic-Compiler vorzusetzen, ggf reicht es schon, eine DLL nur mit den Berechnungen/Funktionen zu erzeugen und diese aus AutoIt aufzurufen.

Anbei der Vergleich des jeweils letzten in der Schleife berechneten Integers, also $ynk2.

Ich habe mir geschenkt, die vom ASM-Code berechneten Werte in einen String zu schreiben (die gehören in eine 16-Bit-"short" Struct, welche ein "Array" ist!) , das hätte den Code nochmal überdimensional aufgepumpt. Nur um einen String zu machen, der dann wieder per StringSplit() in ein Array zerlegt wird uswusf....DAS war aber schon mal Thema^^ //

//EDIT habe ich jetzt doch gemacht...

Aber falls du die Ergebnisse trotzdem vergleichen willst, hier mal ein Ansatz....

Man beachte nach dem ASM-Code die Schleife, die aus der Integer-DllStruct einen String macht, welcher dann in ein Array überführt wirdIch glaub, ich schreib das Script mal komplett auf Dllstruct um....

//EDIT Das bereitet mir körperliche Schmerzen, ich schreibe einen ASM-Code, der aus den Integer einen String macht...

simpel lautheit ASM_forum1.zip

In der Anzeige der Zeit für den ASM-Code ist auch die Umwandlung in einen String und das in AutoIt SEHR langsame Lesen dieses Strings aus dem Speicher enthalten, einfach die beiden Zeilen auskommentieren....bei mir ergibt sich für die eigentliche Berechnung 0.08ms, inclusive der Umwandlung in String und das Lesen sind das 0,23ms...die Differenz von 0.11ms ist zwar nicht die Welt, aber völligst unnötig!

Das darauffolgende Neuberechnen der Arrayinhalte dauert pro Durchlauf bei mir ca. 80-100ms.

Ich schreibe das Script mal weiter um auf komplette Verwendung von DllStructs statt Array, das macht es selbst in reinem AutoIt-Code schätzungsweise 10x schneller!

Aber wie gesagt, das vorliegende Script in einer Compilersprache wäre sowieso schon 100x schneller....

Simpel · 18. Februar 2018

Moin Andy,

Danke schon mal für die bisherigen Ausführungen. Ich bin in DLLStructs leider gar nicht zu Hause. Da muß ich wohl noch mal ordentlich büffeln, um das wirklich zu verstehen. Den riesigen Zeitgewinn zwischen beiden Methoden habe ich gesehen. Dabei hat sich gezeigt, daß ein weiterer großer Zeitfresser das 400ms-Array ist. Allein:

Code

_ArrayDelete($a400msInteger, "0-" & ($i100msSampleCount - 1) & "") ; aus dem 400ms-Array (also Momentary) die obersten 100ms entfernen
_ArrayAdd($a400msInteger, $a100msInteger) ; die aktuellen 100ms hinzufügen

frisst pro 100ms-Runde ca. 100ms Zeit. Das ist natürlich Murks.

Was ich aber auch sehe, wenn ich

Code

_ArrayDisplay($a100msInteger, "IntegerKette")

einschalte, daß mit reinem AutoIt das Array immer die exakten 4800 Werte hat, aber über die DLLStruct die Werte zwischen 4800 und 4812 schwanken. Weißt Du, warum das so ist?

Was Du bisher immer berechnest, ist 1 Kanal Audio hintereinander geschrieben. Es können ja aber bis zu 6 Kanäle sein, die interleaved, im Wechsel codiert sind. In Post 5 habe ich dieses Verhalten bereits berücksichtigt. Wie bekommt man das jetzt mit Deiner Variante hin? Vergrößert sich die Struct mal der Kanäle und greift die K-Filter-Berechnung nur auf die Werte zurück, die nur zu diesem Kanal gehören?

Ich denke mal, daß ich auch ein DLLStruct sowohl für die 400ms, als auch für die 3s schaffen muß und zwar für jeden Kanal extra. Da es Kanäle gibt, die mit Faktor 1,5 und einen Kanal mit Faktor 0 in die Gesamtberechnung eingehen.

Gruß, Conrad

**Andy** · 19. Februar 2018

Zitat von Simpel

Es können ja aber bis zu 6 Kanäle sein, die interleaved, im Wechsel codiert sind. In Post 5 habe ich dieses Verhalten bereits berücksichtigt. Wie bekommt man das jetzt mit Deiner Variante hin? Vergrößert sich die Struct mal der Kanäle und greift die K-Filter-Berechnung nur auf die Werte zurück, die nur zu diesem Kanal gehören?

Es kommt darauf an, wie die Kanäle innerhalb der Datei bzw. des Dateiformats vorliegen. Rudimentär hatte ich diverse "Umformungen" für WAV-Dateien mit Stereo, also 2 Kanälen, mal in Echtzeit vor fast 15 Jahren hingebastelt. Frag mich heute nicht danach^^

Grundsätzlich stellt sich die Frage, was du mit dem Programm überhaupt beabsichtigst. Was soll das werden?

Dann zieht man die Sache entsprechend auf.

Mit den Structs ist das gar keine große Sache. Da werden einfach Bereiche im Speicher reserviert, und entsprechend bearbeitet. Sieht aus wie ein Array, und wird auch ähnlich angesprochen.

Grundsätzlich kannst du mit AutoIt bei deinem Vorhaben und den Mengen an Berechnungen keinen Blumenpott gewinnen, auch nicht bei Verwendung von Structs.

Was geht ist ein "schickes" GUI, die eigentlich einfachen Berechnungen würde ich in Funktionen in eine mit einem Basic-Compiler erstellte DLL auslagern und dann aus AutoIt callen. Dann hast du die Oberfläche in AutoIt, und die Geschwindigkeit eines Compilers.

Mit dem großen Vorteil, dass jedermann mit egal welchem Compiler und Programmiersprache eine ggf. "schnellere" Berechnung schreiben kann.

Da macht dann die Verwendung von ASM nur noch Sinn, wenn es wirklich um die absolute Optimierung geht. Da würde ich allerdings die Challenge gegen herkömmliche Compiler aufnehmen.

Weiterhin sind die zu berechnenden Teile der Daten doch eher übersichtlich "klein", also eigentlich "winzig", nur einige Kilobytes.

Eine weitere Alternative wäre dann die parallele Berechnung mehrerer Kanäle bzw. mehrerer Teilbereiche gleichzeitig. Wenn rudimentäres C (ohne ++) kein Problem darstellt, wäre auch OpenCL eine Alternative....

Zitat von Simpel

daß mit reinem AutoIt das Array immer die exakten 4800 Werte hat, aber über die DLLStruct die Werte zwischen 4800 und 4812 schwanken. Weißt Du, warum das so ist?

Nein, die Struct hat immer die Größe von

Code

$structlen = ($iBitrate / 8 ) * $i100msSampleCount * $iChannels

, das ist beim Start des Programms festgelegt.

Hups, ich habe gerade bemerkt, dass die Länge der TEXT(!)-Daten innerhalb der Struct, also die Stringlänge natürlich unterschiedlich ist. Innerhalb der Struct werden die Daten nicht gelöscht sondern nur überschrieben und somit beim Auslesen wird "der Rest" hinter dem eigentlichen String mitgezählt. Weil dort ein Textende, also CHR(0) fehlt. Wird geändert.

Code

$binarycode ="0x8B7424048B7C24088B54240CC1EA028954240C31D28B1C960FBAE31F7306F7D343B02DAA525189D8BB0A00000031C931D2F7F3665280C10109C075F366580C30AAE2F9C6077C83C701595A423B54240C72C3B000AA89D0C3"

fixt das. Bei _int2string also etwa Zeile 280 austauschen.

Teilen