tag 0.0.2

Toby Mao · Toby Mao · commit f64509ea85ea · 2018-09-05T23:25:25.000+08:00
diff --git a/README.md b/README.md
@@ -1,5 +1,4 @@
-# rcaudio : A Realtime Audio Recording & Analyze Script
-
+# rcaudio : A Realtime Audio Recording & Analyzing Library
 
 ## Introduction 
 
@@ -11,7 +10,12 @@ It supports real-time analysis of :
 * Volume
 * Beat Information
 
-For chinese documentation : [中文文档](http://mhy12345.xyz/technology/python-beat-detection/)
+For chinese documentation : [中文文档](http://mhy12345.xyz/technology/rcaudio-documentation/)
+## Installation
+
+```bash
+pip install rcaudio
+```
 
 ## Usage
 
@@ -46,6 +50,9 @@ All class extended from `BaseAnalyzer` can be registered into `SimpleRecorder`.
 
 
 ```python
+import time
+from rcaudio import SimpleRecorder,VolumeAnalyzer
+
 SR = SimpleRecorder()
 VA = VolumeAnalyzer(rec_time = 1)
 SR.register(VA)
@@ -66,3 +73,21 @@ while True:
     print(BA.block_until_next_beat())
 ```
 
+A FeatureAnalyzer can use to generate all user defined acoustic features. Just override the `data_process` function. (Current function are the calculation of the *Zero Crossing Rate*.
+
+```python
+SR = SimpleRecorder(sr = 1000)
+FA = FeatureAnalyzer(refresh_time = 1)
+SR.register(FA)
+SR.start()
+cpos = 0
+while True:
+	if len(FA.result) > cpos:
+		print(FA.result[cpos])
+		cpos += 1
+	time.sleep(.01)
+```
+
+## Some note
+
+Most function has the time delay about 1-2 seconds. I did lot effort to let the BeatAnalyzer looked as it is real-time. However, for the `FeatureAnalyzer`, if the feature extraction function are too slow compare to the microphone recording, the dalay may become huge. Decrease the sample rates would be a solution, but better solution would be DIY a analyzer yourself.
diff --git a/build/lib/rcaudio/beat_analyzer.py b/build/lib/rcaudio/beat_analyzer.py
@@ -79,11 +79,8 @@ def block_until_next_beat(self):
             self.current_k = self.current_k + (self.expected_k - self.current_k)*(1-self.smooth_ratio)
         if self.current_k < self.initial_k*.45:
             self.current_k *= 2
-            print("INC")
         if self.current_k > self.initial_k * 2.1:
             self.current_k /= 2
-            print("DEC")
-        print(">>>",self.current_k,self.expected_k)
         while time.time() < pred:
             time.sleep(.01)
         return self.beat_count
diff --git a/demo.py b/demo.py
@@ -3,7 +3,7 @@
 import logging
 
 
-logging.basicConfig(level=logging.DEBUG,
+logging.basicConfig(level=logging.INFO,
         format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
 
 
@@ -38,4 +38,33 @@ def demo3():
     while True:
         print(BA.block_until_next_beat())
 
-demo3()
+def demo4():
+    SR = SimpleRecorder(sr = 20000)
+    BA = BeatAnalyzer(rec_time = 15, initial_bpm = 120, smooth_ratio = .8)
+    VA = VolumeAnalyzer(rec_time = 1)
+    SR.register(BA)
+    SR.register(VA)
+    SR.start()
+    low_volume_count = 0
+    while True:
+        v = VA.get_volume() 
+        if v < 50:
+            low_volume_count += 1
+        if low_volume_count > 4:
+            break
+    SR.stop()
+    SR.join()
+
+def demo5():
+    SR = SimpleRecorder(sr = 1000)
+    FA = FeatureAnalyzer(refresh_time = 1)
+    SR.register(FA)
+    SR.start()
+    cpos = 0
+    while True:
+        if len(FA.result) > cpos:
+            print("Zero Crossing Rate : ",FA.result[cpos])
+            cpos += 1
+        time.sleep(.01)
+
+demo5()
diff --git a/dist/rcaudio-0.0.1-py3-none-any.whl b/dist/rcaudio-0.0.1-py3-none-any.whl
diff --git a/dist/rcaudio-0.0.1.tar.gz b/dist/rcaudio-0.0.1.tar.gz
diff --git a/rcaudio.egg-info/PKG-INFO b/rcaudio.egg-info/PKG-INFO
@@ -8,16 +8,72 @@ Author-email: maohanyang789@163.com
 License: UNKNOWN
 Description: # rcaudio : A Realtime Audio Recording & Analyze Script
         
+        
         ## Introduction 
         
-        rcaudio is a realtime audio recording script, it provide easy way to record via microphone and then analyze.
+        **rcaudio** Rcaudio is a real-time audio analysis library that allows you to simply record audio through a microphone and analyze.
         
-        rcaudio provide APIs to get:
+        It supports real-time analysis of :
         
         * The raw audio data
         * Volume
         * Beat Information
         
+        For chinese documentation : [中文文档](http://mhy12345.xyz/technology/python-beat-detection/)
+        
+        ## Usage
+        
+        ### CoreRecorder
+        
+        `CoreRecorder` is used to fetch raw data. When started, the audio data will be stored in the `CoreRecorder.buffer`.
+        
+        ```python
+        from rcaudio import CoreRecorder
+        CR = CoreRecorder(
+                time = 10, #How much time to record
+                sr = 1000 #sample rate
+                )
+        CR.start()
+        while True:
+            if not CR.buffer.empty():
+                x = CR.buffer.get()
+                print('*'*int(abs(x)))
+        ```
+        
+        ### SimpleRecorder
+        
+        In most cases, we use `SimpleRecorder`.  For efficiency consideration, the `SimpleRecorder`  should only be instantiated once. 
+        
+        This class can register several `Analyzer`. 
+        
+        When the function `start()` called, It will begin to record through microphone, and refresh the status of all the `Analyzer`
+        
+        ### Analyzers
+        
+        All class extended from `BaseAnalyzer` can be registered into `SimpleRecorder`. For example `VolumeAnalyzer` can get the current volume of the microphone.
+        
+        
+        ```python
+        SR = SimpleRecorder()
+        VA = VolumeAnalyzer(rec_time = 1)
+        SR.register(VA)
+        SR.start()
+        while True:
+            print("VOLUME : ",VA.get_volume())
+            time.sleep(1)
+        ```
+        
+        And beat analyzer can predict the beats from the music. (However, there will be some delay.)
+        
+        ```python
+        SR = SimpleRecorder(sr = 20000)
+        BA = BeatAnalyzer(rec_time = 15, initial_bpm = 120, smooth_ratio = .8)
+        SR.register(BA)
+        SR.start()
+        while True:
+            print(BA.block_until_next_beat())
+        ```
+        
         
 Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
diff --git a/rcaudio/__init__.py b/rcaudio/__init__.py
@@ -4,11 +4,13 @@
 
 from .volume_analyzer import VolumeAnalyzer
 from .beat_analyzer import BeatAnalyzer
+from .feature_analyzer import FeatureAnalyzer
 
 __all__ = [
         "CoreRecorder",
         "SimpleRecorder",
         "BaseAnalyzer",
         "VolumeAnalyzer",
-        "BeatAnalyzer"
+        "BeatAnalyzer",
+        "FeatureAnalyzer"
         ]
diff --git a/rcaudio/base_analyzer.py b/rcaudio/base_analyzer.py
@@ -12,11 +12,14 @@ def __init__(self):
         self.logger = logging.getLogger(str(self.__class__))
 
     def stop(self):
-        logger.warn("Stop signal received")
+        self.logger.debug("Stop signal received")
         self.running.clear() 
         
     def register_recorder(self,recorder):
         self.audio_data = recorder.audio_data
         self.sr = recorder.sr
         self.recorder = recorder
 
+    def is_running(self):
+        return self.running.isSet()
+
diff --git a/rcaudio/beat_analyzer.py b/rcaudio/beat_analyzer.py
@@ -66,7 +66,6 @@ def block_until_next_beat(self):
             exp_i = math.ceil((pred_v2 - self.expected_b)/self.expected_k)
             exp_v2 = exp_i * self.expected_k + self.expected_b
             exp_v1 = exp_v2 - self.expected_k
-            print(exp_v1,pred_v2,exp_v2)
             if (pred_v2-exp_v1) < (exp_v2-pred_v2):
                 pred = pred_v2 + (exp_v1-pred_v2)*(1-self.smooth_ratio)
                 self.beat_count += pred_i 
@@ -79,11 +78,8 @@ def block_until_next_beat(self):
             self.current_k = self.current_k + (self.expected_k - self.current_k)*(1-self.smooth_ratio)
         if self.current_k < self.initial_k*.45:
             self.current_k *= 2
-            print("INC")
         if self.current_k > self.initial_k * 2.1:
             self.current_k /= 2
-            print("DEC")
-        print(">>>",self.current_k,self.expected_k)
         while time.time() < pred:
             time.sleep(.01)
         return self.beat_count
diff --git a/rcaudio/feature_analyzer.py b/rcaudio/feature_analyzer.py
@@ -0,0 +1,45 @@
+from .base_analyzer import BaseAnalyzer
+import librosa
+import time
+import math
+import numpy as np
+
+class FeatureAnalyzer(BaseAnalyzer):
+    def __init__(self,
+            refresh_time = 1
+            ):
+        BaseAnalyzer.__init__(self)
+        self.refresh_time = refresh_time
+        self.cpos = 0
+        self.result = []
+
+    def register_recorder(self,recorder):
+        BaseAnalyzer.register_recorder(self,recorder)
+        self.refresh_size = self.sr * self.refresh_time
+
+    def data_process(self,data):
+        def ZeroCR(waveData,frameSize,overLap):
+            #http://ibillxia.github.io/blog/2013/05/15/audio-signal-processing-time-domain-ZeroCR-python-realization/
+            wlen = len(waveData)
+            step = frameSize - overLap
+            frameNum = math.ceil(wlen/step)
+            zcr = np.zeros((frameNum,1))
+            for i in range(frameNum):
+                curFrame = waveData[np.arange(i*step,min(i*step+frameSize,wlen))]
+                curFrame = curFrame - np.mean(curFrame) # zero-justified
+                zcr[i] = sum(curFrame[0:-1]*curFrame[1::]<=0)
+            return zcr
+        zcr = ZeroCR(data,512,0)
+        return data[0]
+
+    def run(self):
+        while self.recorder.start_time is None:
+            time.sleep(1)
+
+        while self.running.isSet():
+            while len(self.audio_data) > self.cpos + self.refresh_size:
+                data = np.array(self.audio_data[self.cpos:self.cpos + self.refresh_size]).astype(np.float32)
+                data = self.data_process(data)
+                self.result.append(data)
+                self.cpos += self.refresh_size
+
diff --git a/rcaudio/volume_analyzer.py b/rcaudio/volume_analyzer.py
@@ -1,5 +1,3 @@
-import threading
-import logging
 import time
 import queue
 from .base_analyzer import BaseAnalyzer
@@ -21,7 +19,7 @@ def register_recorder(self,recorder):
         self.rec_size = self.sr * self.rec_time
 
     def run(self):
-        while self.audio_data is None:
+        while self.start_time is None:
             time.sleep(1)
         while self.running.isSet():
             while len(self.audio_data) > self.cpos:
diff --git a/setup.py b/setup.py
@@ -5,10 +5,10 @@
 
 setuptools.setup(
     name="rcaudio",
-    version="0.0.1",
+    version="0.0.2",
     author="mhy12345",
     author_email="maohanyang789@163.com",
-    description="A realtime audio recording scripts",
+    description="A real-time audio recording & analyzing library",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/mhy12345/rcaudio",
