Bash: Capture stdError von looped Stream

Question

Ich habe eine cpp ausführbare (mycat), die kontinuierlich lesen Sie eine Schleife Audio-Stream aus dem gemeinsamen Speicher und leitet die Daten zu stdOut und die Metadaten-Informationen zu stdErr. mycat Rohre aus 12 Linien für jeden Eintrag des Audio-Streams, die Metadaten-Informationen enthält, wie folgt aussehen:

0x1 (TimeStamp) 12Bytes:2956 +  6793/(47999+1) (0.141521) delta= 0+ 1536/(47999+1) (0.032000) 2956.151418 -9.898ms 2016.04.04 16:06:37.700 
0x4 (ReferenceTime) 12Bytes:2956 + 6156972/(26999999+1) (0.228036) delta= 0+ 1618519/(26999999+1) (0.059944) 2956.151426 76.610ms 2016.04.04 16:06:37.700 
0x6 (ProcessDelay) 4Bytes: 64 (0x40) 
0x7 (ClockAccuracy) 8Bytes: offset=0.000ppm (+-0.000ppm) 
0xb (ClockId) 8Bytes: 01 00 00 00 42 22 01 00 
0x20001 (SampleRate) 4Bytes: 48000 (0xbb80) 
0x20002 (Channels) 4Bytes: 6 (0x6) 
0x20003 (PcmLevel) 24Bytes: -21307 -20348 -31737 -42427 -28786 -26525 
0x20004 (PcmPeak) 24Bytes: -14366 -13360 -25203 -39427 -19067 -21307 
0x2000e (DolbyDpMetadata) 39352Bytes: 
Linear Time: 2956 +  6793/(47999+1) (0.141521) delta= 0+ 1536/(47999+1) (0.032000) 
2016.04.04 16:06:37.700 update: slot=0xe2840 validTo=0x3d1dd180 shmT=0x3d195200 (delta=294784) doffset=0xec2c0 msize=39552 dsize=18432 type=0x20001 (PCMS16) data bytes: df f4 f2 fc 

Was ich will, ist ein Bash-Skript, dass:

1) Einführung mycat zB. ./mycat shm_name > /dev/null.

2) liest stdErr von mycat bis zur zwölften Zeile, egal wo es angefangen hat.

2.1) speichern schließlich die Linie 12 in eine Variable (dies ist optional)

3) immedialy tötet mycat nach der 12. Zeile, so dass der Schlagindex ohne verärgert durch die outcoming stderror fortsetzen kann.

4) Lesen des Wertes der Zeile „Kanäle“ (in diesem Fall 6) und speichert sie auf eine Variable mit dem Namen „Kanäle“

5) Lesen des Wertes der Zeile „Sample“ (in diesem Fall 48000) und speichert es die Variable "rate"

Gibt es eine Möglichkeit, es zu tun?

Answer 1

finde ich eine elegante Lösung aus:

while read -r line;           # Read mycat line by line 
do 
    if echo "$line" | grep -qi "SampleRate"; then   # Search for line containing string 'SampleRate' 
     rate="${line#*:}";         # Remove all charachters till ':' 
     rate="${rate%(*}";         # Remove all charachters from '(' 
     rate="$(echo -e "${rate}" | tr -d '[[:space:]]')" # Remove all tralling withespace 
    elif echo "$line" | grep -qi "Channels"; then 
     channels="${line#*:}"; 
     channels="${channels%(*}"; 
     channels="$(echo -e "${channels}" | tr -d '[[:space:]]')" 
    fi 

    if [ -n "$channels" ] && [ -n "$rate" ]; then   # If both variables 'channels' and 'rate' are not empty kill the while loop 
     break; 
    fi 
done < <(./mycat $shm_name 2>&1 > /dev/null)   # Mycat is processed into a while loop, standard Error is redirected to standard Output (2>&1) 

echo "Found datarate: $rate" 
echo "Found channels: $channels" 

Answer 2

Sie können stderr mit mycat shm_name > /dev/null 2>/path/to/file umleiten. Sie können Mycat mit killall mycat töten, wenn die Zeit kommt. Zum Speichern der Variablen möchten Sie export channels =, dasselbe Muster mit Rate. Sie können diese mit grep finden. Ich bin mir aber nicht sicher, wie ich genau zwölf Zeilen warten soll.

Answer 3

Zuerst müssen Sie STDERR auf STDOUT umleiten und STDOUT auf null setzen.

mycat 2>&1 >/dev/null | parsing_script 

Dann brauchen Sie einen Parsing-Skript Daten

#!/bin/bash 

declare -a data=() 
count=1 
while read line; do 
    data+=("$line 
    ") 
    ((count++)) 

    string=$(echo $line|sed 's/.*(\(.[A-Za-z]*\)).*/\1/') 
    case $string in 
     SampleRate) rate=$(echo $line|sed 's/.*: \(.[0-9]*\) .*/\1/') 
     ;; 
     Channels) channels=$(echo $line|sed 's/.*: \(.[0-9]*\) .*/\1/') 
     ;; 
     *) true;; 
    esac 
    if [[ $count -gt 12 ]]; then 
     break 
    fi 
done <&0 

echo $channels 
echo $rate 

ich die Werte echo'd zu sammeln, aber Sie können sie in eine Datei umleiten, formatieren, etc. Auch $ {Daten [@]} enthält deine Metadaten. Da Sie Piping sind, lese ich von STDIN, aber es könnte robuster sein, wenn Sie es zwicken wollen.