एक ऑडियो लाइन की निगरानी

Question

मुझे अपने ऑडियो लाइन-इन में लिनक्स में मॉनीटर करने की आवश्यकता है, और जब ऑडियो चलाया जाता है, तो ध्वनि रिकॉर्ड और फ़ाइल में सहेजी जानी चाहिए। motion वीडियो फ़ीड पर नज़र रखता है।

क्या यह बैश के साथ ऐसा करना संभव है?

#!/bin/bash 

# audio device 
device=/dev/audio-line-in 

# below this threshold audio will not be recorded. 
noise_threshold=10 

# folder where recordings are stored 
storage_folder=~/recordings 

# run indefenitly, until Ctrl-C is pressed 
while true; do 
    # noise_level() represents a function to determine 
    # the noise level from device 
    if noise_level($device) > $noise_threshold; then 
    # stream from device to file, can be encoded to mp3 later. 
    cat $device > $storage_folder/$(date +%FT%T).raw   
    fi; 
done; 

संपादित करें: की तर्ज पर कुछ प्रवाह मैं इस कार्यक्रम से प्राप्त करना चाहते हैं

a. when noise > threshold, start recording 
b. stop recording when noise < threshold for 10 seconds 
c. save recorded piece to separate file 

Answer 1

SoX ध्वनि प्रसंस्करण के स्विस सेना चाकू है। आप इसे रिकॉर्डिंग का विश्लेषण करने के लिए उपयोग कर सकते हैं। folowing समाधान के केवल कमी है:

1. आप तय आकार विखंडू करने के लिए रिकॉर्डिंग को विभाजित करने की जरूरत है
2. आप रिकॉर्डिंग समय

(की मौत हो गई/विश्लेषण/रिकॉर्डिंग के पुनरारंभ के कारण) खो सकते हैं

तो आगे के सुधार एसिंक्रोनस का विश्लेषण कर सकते हैं, हालांकि यह नौकरी को जटिल करेगा।

#!/bin/bash 

record_interval=5 
noise_threshold=3 
storage_folder=~/recordings 

exec 2>/dev/null  # no default error output 
while true; do 
    rec out.wav & 
    sleep $record_interval 
    kill -KILL %1 
    max_level="$(sox out.wav -n stats -s 16 2>&1|awk '/^Max\ level/ {print int($3)}')" 
    if [ $max_level -gt $noise_threshold ];then 
    mv out.wav ${storage_folder}/recording-$(date +%FT%T).wav; 
    else 
    rm out.wav 
    fi 
done 

अद्यतन:

निम्नलिखित समाधान आरईसी से आउटपुट के रूप में एक फीफो उपयोग करता है।

#!/bin/bash 

noise_threshold=3 
storage_folder=~/recordings 
raw_folder=~/recordings/tmp 
split_folder=~/recordings/split 
sox_raw_options="-t raw -r 48k -e signed -b 16" 
split_size=1048576 # 1M 

mkdir -p ${raw_folder} ${split_folder} 

test -a ${raw_folder}/in.raw || mkfifo ${raw_folder}/in.raw 

# start recording and spliting in background 
rec ${sox_raw_options} - >${raw_folder}/in.raw 2>/dev/null & 
split -b ${split_size} - <${raw_folder}/in.raw ${split_folder}/piece & 


while true; do 
    # check each finished raw file 
    for raw in $(find ${split_folder} -size ${split_size}c);do 
    max_level="$(sox $sox_raw_options ${raw} -n stats -s 16 2>&1|awk '/^Max\ level/ {print int($3)}')" 
    if [ $max_level -gt $noise_threshold ];then 
     sox ${sox_raw_options} ${raw} ${storage_folder}/recording-$(date +%FT%T).wav; 
    fi 
    rm ${raw} 
    done 
    sleep 1 
done1 

Answer 2

यहाँ कैसे जम्मू ü rgen के समाधान के सुधार करने के लिए एक स्केच है:: इस पाइप पर विभाजन का उपयोग कर हिस्सा पाने के लिए तक, वहाँ रिकॉर्डिंग समय का कोई नुकसान नहीं होना चाहिए कि यह सिर्फ डबल बफरिंग है, तो आप कर रहे हैं, जबकि एक फ़ाइल का विश्लेषण करना जो आपने पहले ही रिकॉर्डिंग शुरू कर दिया है। मेरा अनुमान है कि यह चाल 100 मिलीसेकंड के क्रम में अंतराल को कम कर देगी, लेकिन आपको पता लगाने के लिए कुछ प्रयोग करना होगा।

पूरी तरह से अनचाहे!

#!/bin/bash 

record_interval=5 
noise_threshold=3 
storage_folder=~/recordings 

exec 2>/dev/null  # no default error output 

function maybe_save { # out.wav date 
    max_level="$(sox "$1" -n stats -s 16 2>&1| 
       awk '/^Max\ level/ {print int($3)}')" 
    if [ $max_level -gt $noise_threshold ]; then 
     mv "$1" ${storage_folder}/recording-"$2" 
    else 
     rm "$1" 
    fi 
} 

i=0 
while true; do 
    this=out$i.wav 
    rec $this & 
    pid=$? 
    if [ $i -gt 9 ]; then i=0; else i=$(expr $i + 1); fi 
    archive=$(date +%FT%T).wav; 
    sleep $record_interval 
    kill -TERM $pid 
    maybe_save $this $archive & 
done 

कुंजी पल आप रिकॉर्डिंग प्रक्रिया को मारने, आप पृष्ठभूमि में विश्लेषण का शुभारंभ और फिर अगले टुकड़ा रिकॉर्ड करने के लिए पाश के आसपास एक और यात्रा करता है। वास्तव में आपको अगली रिकॉर्डिंग प्रक्रिया को पहले लॉन्च करना चाहिए, फिर विश्लेषण, लेकिन नियंत्रण प्रवाह को थोड़ा सा बना देगा। मैं यह देखने के लिए पहले मापूंगा कि आपको किस प्रकार की स्किप्स मिल रही हैं।

Answer 3

यहां एक बेहतर विकल्प भी है;

sox -t alsa default ./recording.flac silence 1 0.1 5% 1 1.0 5%

यह एक ऑडियो फ़ाइल पैदा करता है, वह भी तब, आवाज़ है, और मौन बाहर काट देता है। तो उपरोक्त सामान की तरह कोई अंतराल और कोई लंबी चुप्पी नहीं!

Answer 4

rec -c CHANNELS -r RATE -b BITS -n OUTPUT.AUDIOTYPE noisered NOISEREDUCTION.noise-profile silence 1 5 1% 1 1t 1% 

यह लगातार डिफ़ॉल्ट माइक्रोफोन इनपुट निगरानी करेंगे जब तक एक आवाज सुनी जाती है कि पृष्ठभूमि शोर कम प्रोफ़ाइल का 1% से अधिक है, तो उत्पादन AUDIOTYPE (mp4, FLAC, wav, कच्चे, आदि) की एक फ़ाइल पर रेट एचजे, बिट्स, चैनल। रिकॉर्डिंग 1 सेकंड के चुप्पी के बाद रुक जाएगी जैसा शोर कम स्तर के 1% पर मापा जाता है। आउटपुट फ़ाइल पृष्ठभूमि शोर (ज्यादातर) से साफ हो जाएगी।

अब, अगर कोई मुझे बता सकता है कि रिकॉर्डिंग प्रोग्रामेटिक रूप से बंद हो गई है, तो मैं निरंतर निगरानी ध्वनि पहचान के लिए इसे उपयोगी बना सकता हूं।