示例#1
0
 def __init__(self, preview=False, max_video_length=MAX_VIDEO_LENGTH):
     log.info("booting up..")
     self.final_dir = self._setup_dirs()
     self.max_video_length = max_video_length
     self.video_recorder = VideoRecorder(preview=preview)
     self.audio_recorder = AudioRecorder()
     time.sleep(2)
     log.info("ready!")
示例#2
0
class PatternDumpController:
    def __init__(self):
        self._audio_recorder = AudioRecorder()
        self._sequencer = Sequencer(start_callback=self._audio_recorder.start)

    def get_output_ports(self):
        return self._sequencer.get_output_ports()

    def set_output_port(self, port):
        self._sequencer.set_output_port(port)

    def get_audio_devices(self):
        return self._audio_recorder.get_audio_devices()

    def set_audio_device(self, device, samplerate, bitrate):
        self._audio_recorder.set_audio_device(device)
        self._audio_recorder.samplerate = samplerate
        self._audio_recorder.bitrate = bitrate

    def set_midi_channel(self, channel: int) -> None:
        if not (channel > 0 and channel <= 16):
            raise WrongChannelError
        self._sequencer.set_midi_channel(channel)

    def dump_pattern(self, tempo: int, pattern: int, bank: str,
                     length: int) -> None:
        pattern_event = PatternEvent(0, Pattern(pattern, bank, length), 1)
        for track in range(1, 9):
            logging.info(f'Recording track {track}')
            mute_event = MuteEvent(0, (track, ))
            events = [pattern_event, mute_event]
            sequence = Sequence(tempo, events)
            self._audio_recorder.filename = f'track{track}.wav'
            self._audio_recorder.prepare_recording()
            self._sequencer.set_sequence(sequence)
            self._sequencer.start(blocking=True)
            self._audio_recorder.stop()
        logging.info('All tracks recorded')
示例#3
0
def main():
    ''' Entry point when started from the command line.
    '''

    if len(sys.argv) < 5:
        print('Please, provide the following arguments, and try again:')
        print(
            '\t-> Bing Speech API key (obtain from your Microsoft Azure account)'
        )
        print('\t-> Language (e.g. en-US)')
        print('\t-> Response format [simple/detailed]')
        print('\t-> Recognition mode [interactive/conversation/dictation]')
        print(
            '\t-> [optional] Path to an audio recording (must be WAV, 16-bit, 16kHz)'
        )
        exit()

    api_key = sys.argv[1]
    language = sys.argv[2]
    response_format = sys.argv[3]
    recognition_mode = sys.argv[4]

    if len(sys.argv) == 6:
        audio_file_path = sys.argv[5]
        if not os.path.isfile(audio_file_path):
            print('Error: file does not exist.')
            exit()
    else:
        # prompt the user to create a recording
        record_response = input(
            '\nYou did not provide an audio file. Are you ready to record the query? (You will have 10 seconds.) [Y/n]'
        )
        if record_response.lower() != 'y' and len(record_response) > 0:
            exit()

        # record the audio
        rec = AudioRecorder()
        audio_file_path = rec.start()

    client = SpeechClient(api_key)
    print('\nProcessing...\n')

    # start the event loop and initialize the speech client
    loop = asyncio.get_event_loop()
    loop.run_until_complete(
        client.connect_to_speech_api(language, response_format,
                                     recognition_mode))

    # query the speech API
    output = loop.run_until_complete(client.speech_to_text(audio_file_path))

    # print the result
    if output != '':
        print('\n>> Recognized phrase: ' + output + '\n')
    else:
        print('\n>> Sorry, we were unable to recognize the utterance.\n')

    # client.reset()
    # loop.run_until_complete(client.speech_to_text(audio_file_path))

    # close the connection and stop the event loop
    loop.run_until_complete(client.disconnect())
    loop.close()
示例#4
0
class App:
    def __init__(self, preview=False, max_video_length=MAX_VIDEO_LENGTH):
        log.info("booting up..")
        self.final_dir = self._setup_dirs()
        self.max_video_length = max_video_length
        self.video_recorder = VideoRecorder(preview=preview)
        self.audio_recorder = AudioRecorder()
        time.sleep(2)
        log.info("ready!")

    def _setup_dirs(self):
        final_dir = os.path.expanduser('~/media/')
        if (os.path.isdir(final_dir) == False):
            os.mkdir(final_dir)
        return final_dir

    def _make_filename(self):
        return datetime.datetime.now().strftime("%Y-%m-%d-%H:%M:%S")

    def has_space(self):
        statvfs = os.statvfs("/")
        megabytes_available = int(statvfs.f_frsize * statvfs.f_bavail / 1024 /
                                  1024)
        log.info(f"Still {megabytes_available}MB left on device")
        return megabytes_available > MIN_DISK_SPACE_MB

    def on_keyboard_release(self, key):
        if key == keyboard.Key.enter:
            if lock.locked():
                self.stop_recording()
            elif self.has_space():
                self.start_recording()
            else:
                return False
        if key == keyboard.Key.esc:
            if lock.locked():
                self.stop_recording()
            return False

    def timer(self, seconds, current_video):
        log.info(f"going to sleep for {seconds}s and then stop recording")
        for i in range(seconds):
            if not lock.locked():
                log.info("looks like recording has ended before timeout")
                return
            elif current_video != self.file_name:
                log.info("there is a different ongoing recording")
                return
            time.sleep(1)
        log.info("time's up!, stopping recording")
        self.stop_recording()

    def start_recording(self):
        lock.acquire()
        self.start_datetime = datetime.datetime.now()
        self.file_name = self._make_filename()
        timer_thread = threading.Thread(target=self.timer,
                                        args=(self.max_video_length,
                                              self.file_name))
        timer_thread.start()
        self.tmp_dir = tempfile.mkdtemp()

        log.info("starting threads...")
        self.video_recorder.start(self.file_name, self.tmp_dir)
        self.audio_recorder.start(self.file_name, self.tmp_dir)

    def stop_recording(self):
        log.info("stopping threads...")
        if not self.audio_recorder.stop():
            return
        if not self.video_recorder.stop():
            return
        now = datetime.datetime.now()
        video_length = (now - self.start_datetime).seconds
        if video_length > MIN_VIDEO_LENGTH:
            log.info("starting mux...")
            cmd = (
                f"ffmpeg -i {self.tmp_dir}/{self.file_name}.wav -i {self.tmp_dir}/{self.file_name}.h264 "
                f"-c:v copy -c:a aac -strict experimental {self.final_dir}/{self.file_name}.mp4"
            )
            subprocess.run(cmd, capture_output=True, shell=True)
            log.info(f"{self.file_name}.mp4 is ready!")
        else:
            log.info(f"Video was to short: {video_length}, removing it")
        shutil.rmtree(self.tmp_dir)
        log.info(f"{self.tmp_dir} removed")
        lock.release()

    def run(self):
        def on_release(button):
            if lock.locked():
                self.stop_recording()
            elif self.has_space():
                self.start_recording()
            else:
                return False

        button = Button(2)
        button.when_released = on_release
        listener = keyboard.Listener(on_release=self.on_keyboard_release)
        listener.start()
        pause()
示例#5
0
def on_language_change(language_code):
    global current_language_code
    current_language_code = language_code
    display.show(language_code)

    iot_client.publish(topic='talko/config-topic',
                       payload=json.dumps({
                           "device_id": DEVICE_ID,
                           "lang": language_code,
                       }))


with PhysicalInterface as physical_interface:
    physical_interface.on_language_change = on_language_change
    print('=== {} READY ==='.format(physical_interface.__class__.__name__))
    with AudioRecorder(RECORDING_DEVICE_NAME) as audio_recorder:
        audio_recorder.completion_callback = on_new_recording
        print('=== {} READY ==='.format(audio_recorder.__class__.__name__))
        try:
            while True:
                physical_interface.tick()
                audio_recorder.tick(
                    physical_interface.is_push_to_talk_button_pressed)
                sleep(0.05)
        except KeyboardInterrupt:
            pass


def dummy_handler(event, context):
    pass
示例#6
0
 def __init__(self):
     self._audio_recorder = AudioRecorder()
     self._sequencer = Sequencer(start_callback=self._audio_recorder.start)
示例#7
0
    def __init__(self):
        super(MainWindow, self).__init__()
        self.ui = Ui_dialog()
        self.ui.setupUi(self)
        self.setFixedSize(self.width(), self.height())
        self.onBindingUI()

        ##
        self.record_header_labels = [
            'who', 'what', 'when', 'where', 'speaking'
        ]

        ## Create detail speaking information window
        self.speaking_ui_cam1 = SpeakingMainWindow()
        self.speaking_ui_cam2 = SpeakingMainWindow()

        ## For audio and video analysis from camera
        global video_thread_cam1
        global video_thread_cam2
        global audio_thread_cam1
        global audio_thread_cam2

        ## For showing Quadro W record
        global nobody_record
        global chung_chih_record
        global yu_sung_record
        global chang_yu_record
        global i_hsin_record
        global tzu_yuan_record
        global chih_yu_record
        global other_record

        ## For Q Learing
        global nobody_q_table
        global chung_chih_q_table
        global yu_sung_q_table
        global chang_yu_q_table
        global i_hsin_q_table
        global tzu_yuan_q_table
        global other_q_table

        ## Create video and audio proces thread and process them to get Quadro W info
        audio_thread_cam1 = AudioRecorder(
            cam_ip='rtsp://*****:*****@192.168.65.66:554/stream1',
            audio_spath='temporarily_rtsp_data/for_speaking/cam1',
            audio_stime=5,
            pos_path='nlp_recognize/pos.json',
            dict_path='nlp_recognize/extra_dict.txt')
        video_thread_cam1 = VideoRecorder(
            cam_ip='rtsp://*****:*****@192.168.65.66:554/stream1',
            record_path='record/',
            qtable_path='q_table/',
            compress_result=True,
            fps=15,
            analysis_sec=1,
            prefix_name="cam1",
            audio_thread=audio_thread_cam1,
            human_model_path=
            "trans_model/model_simulated_RGB_mgpu_scaling_append.0024.pb",
            face_model_path='trans_model/face_new3.pb',
            place_model_path='trans_model/place_new3.pb',
            object_model_path=
            'object_recognize/code/workspace/training_demo/model/pb/frozen_inference_graph.pb',
            face_category_path='face_recognize/categories_human_uscc.txt',
            place_category_path='places_recognize/categories_places_uscc.txt',
            object_category_path=
            'object_recognize/code/workspace/training_demo/annotations/label_map.pbtxt'
        )
        audio_thread_cam2 = AudioRecorder(
            cam_ip='rtsp://*****:*****@192.168.65.41:554/stream1',
            audio_spath='temporarily_rtsp_data/for_speaking/cam2',
            audio_stime=5,
            pos_path='nlp_recognize/pos.json',
            dict_path='nlp_recognize/extra_dict.txt')
        video_thread_cam2 = VideoRecorder(
            cam_ip='rtsp://*****:*****@192.168.65.41:554/stream1',
            record_path='record/',
            qtable_path='q_table/',
            compress_result=True,
            fps=15,
            analysis_sec=1,
            prefix_name="cam2",
            audio_thread=audio_thread_cam2,
            human_model_path=
            "trans_model/model_simulated_RGB_mgpu_scaling_append.0024.pb",
            face_model_path='trans_model/face_new3.pb',
            place_model_path='trans_model/place_new3.pb',
            object_model_path=
            'object_recognize/code/workspace/training_demo/model/pb/frozen_inference_graph.pb',
            face_category_path='face_recognize/categories_human_uscc.txt',
            place_category_path='places_recognize/categories_places_uscc.txt',
            object_category_path=
            'object_recognize/code/workspace/training_demo/annotations/label_map.pbtxt'
        )

        ## Create thread to show record of Quadro W info
        nobody_record = RecordUpdata(csv_path="record/Nobody_record.csv")
        chung_chih_record = RecordUpdata(
            csv_path="record/chung-chih_record.csv")
        yu_sung_record = RecordUpdata(csv_path="record/yu-sung_record.csv")
        chang_yu_record = RecordUpdata(csv_path="record/chang-yu_record.csv")
        i_hsin_record = RecordUpdata(csv_path="record/i-hsin_record.csv")
        tzu_yuan_record = RecordUpdata(csv_path="record/tzu-yuan_record.csv")
        chih_yu_record = RecordUpdata(csv_path="record/chih-yu_record.csv")

        ## Create thread to calculate Q value and show
        nobody_q_table = QLearningUpdata(
            in_record_path="record/Nobody_record.csv",
            out_table_path="q_table/Nobody_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)
        chung_chih_q_table = QLearningUpdata(
            in_record_path="record/chung-chih_record.csv",
            out_table_path="q_table/chung-chih_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)
        yu_sung_q_table = QLearningUpdata(
            in_record_path="record/yu-sung_record.csv",
            out_table_path="q_table/yu-sung_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)
        chang_yu_q_table = QLearningUpdata(
            in_record_path="record/chang-yu_record.csv",
            out_table_path="q_table/chang-yu_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)
        i_hsin_q_table = QLearningUpdata(
            in_record_path="record/i-hsin_record.csv",
            out_table_path="q_table/i-hsin_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)
        tzu_yuan_q_table = QLearningUpdata(
            in_record_path="record/tzu-yuan_record.csv",
            out_table_path="q_table/tzu-yuan_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)
        chih_yu_q_table = QLearningUpdata(
            in_record_path="record/chih-yu_record.csv",
            out_table_path="q_table/chih-yu_qtable.csv",
            where_pool=[[2], [1], []],
            where_category_path="places_recognize/categories_places_uscc.txt",
            care_number=100,
            decay_reward=0.98,
            base_reward=100,
            lower_limit=1,
            decay_qvalue=0.9,
            learning_rate=0.1)

        ## Start all thread
        video_thread_cam1.start()
        video_thread_cam2.start()
        audio_thread_cam1.start()
        audio_thread_cam2.start()

        nobody_record.start()
        chung_chih_record.start()
        yu_sung_record.start()
        chang_yu_record.start()
        i_hsin_record.start()
        tzu_yuan_record.start()
        chih_yu_record.start()

        nobody_q_table.start()
        chih_yu_q_table.start()
        yu_sung_q_table.start()
        chang_yu_q_table.start()
        i_hsin_q_table.start()
        tzu_yuan_q_table.start()
        chang_yu_q_table.start()

        self.timer = QTimer(self)
        self.timer.timeout.connect(self.start_webcam)
        self.timer.start(0)
示例#8
0
from audio_player import AudioPlayer
from audio_recorder import AudioRecorder
import time
import os

if __name__ == "__main__":
    # Usage example for pyaudio
    while True:
        # play the audio
        a = AudioPlayer("sample_1202.wav")
        print("Start Playing: {}".format(time.time()))
        os.system("ping -c 1 1.1.1.1")  # punch play start
        a.play(start=0, end=11.5)
        print("End Playing: {}".format(time.time()))
        os.system("ping -c 1 8.8.4.4")  # punch play end
        a.close()

        # Start recording
        b = AudioRecorder()
        print("Waiting")
        print()
        time.sleep(180)