def evaluate( model, dataset, log_dir: str, batch_size: int, device: str, **kwargs, ) -> None: """ Evaluate accuracy. """ if (device != "cpu") and (torch.cuda.device_count() > 1): model = torch.nn.DataParallel(model) log_path = os.path.join(log_dir, os.path.join("result.csv")) logger = Logger(path=log_path, mode="test") loader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True, ) with tqdm.tqdm(total=int(len(dataset) / batch_size), ncols=80) as pbar: accuracies = list() for x, y in loader: x, y = x.to(device), y.to(device) with torch.autograd.no_grad(): y_predict_std = model(x) stdacc1, stdacc5 = accuracy(y_predict_std, y, topk=(1, 5)) accuracies.append(stdacc1.item()) pbar.set_postfix(collections.OrderedDict(acc="{}".format(stdacc1.item()))) pbar.update() log_dict = collections.OrderedDict() log_dict["accuracy"] = sum(accuracies) / float(len(accuracies)) logger.log(log_dict)
def run(self): preexec_fn = None if platform.system() == "Windows" else os.setsid cmd = ["adb", "-s", self.serialno, "logcat"] cmd = cmd + ["-b", self.buffername] if self.buffername else cmd Logger.log("LogcatOutputThread", "threadloop is listening with the command '{}'".format(cmd)) self.proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=preexec_fn) while not self.stoprequest.isSet(): if self.proc.poll() != None: break line = self.proc.stdout.readline() if sys.version_info.major > 2: line = line.decode("utf-8", errors="ignore") if not self.lasttime_update_timer.is_alive( ): # start for the first time self.lasttime_update_timer.start() else: # reset for the followings self.lasttime_update_timer.reset() self._handle_logcat_msg(line) self.lasttime_update_timer.join() try: if platform.system() != "Windows": os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM) except: pass
def wait_for_event(self, event, timeout): cnt = 0 while cnt < timeout * 10: cnt += 1 if self.stoprequest.isSet(): return -1 try: ev = self.event_q.get(timeout=0.1) Logger.log(self.get_tag(), "get event: {}".format(ev)) if ev[0] == event: return ev[1] except queue.Empty: with self.event_q.mutex: current_event = self.current_event if current_event: active_or_inactive = DetectionStateListener.Event.ACTIVE \ if current_event[1] == ToneDetector.Event.TONE_DETECTED else \ DetectionStateListener.Event.INACTIVE if active_or_inactive == event: Logger.log( self.get_tag(), "the current state '{}' fits the waited event". format(event)) return 0 return -1
def run(self): # shell_cmd = "screenrecord --bit-rate 4000000 /sdcard/screenrecord.mp4" shell_cmd = "screenrecord /sdcard/screenrecord.mp4" cmd = ["adb", "-s", self.serialno, "shell", shell_cmd] Logger.log("AdbScreenRecordingThread", "threadloop is running with the command '{}'".format(cmd)) self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def freq_cb(msg): strs = msg.split() freq, amp_db = map(float, strs[-1].split(",")) the_date, the_time = strs[:2] time_str = the_date + " " + the_time if shared_vars["last_freq"] != freq: self.push_to_dump( \ "the detected freq has been changed from {} to {} Hz".format(shared_vars["last_freq"], freq)) shared_vars["last_freq"] = freq thresh = 10 if self.target_freq else 1 if super(ToneDetectorForDeviceThread, self).target_detected(freq): self.event_counter += 1 if self.event_counter == 1: shared_vars["start_time"] = time_str if self.event_counter == thresh: if not shared_vars["last_event"] or shared_vars[ "last_event"] != ToneDetector.Event.TONE_DETECTED: Logger.log( "ToneDetectorForDeviceThread", "send_cb({}, TONE_DETECTED)".format( shared_vars["start_time"])) self.cb((shared_vars["start_time"], ToneDetector.Event.TONE_DETECTED)) shared_vars[ "last_event"] = ToneDetector.Event.TONE_DETECTED else: if self.event_counter > thresh: shared_vars["start_time"] = None self.push_to_dump( "the tone is not detected and the event_counter is over the threshold" ) self.push_to_dump("last_event: \"{}\"".format( shared_vars["last_event"])) if not shared_vars["last_event"] or shared_vars[ "last_event"] != ToneDetector.Event.TONE_MISSING: Logger.log( "ToneDetectorForDeviceThread", "send_cb({}, TONE_MISSING)".format(time_str)) self.cb((time_str, ToneDetector.Event.TONE_MISSING)) shared_vars[ "last_event"] = ToneDetector.Event.TONE_MISSING self.event_counter = 0 if self.event_counter <= thresh: self.push_to_dump("event_counter: {}".format( self.event_counter))
def wait_for_event(self, event, timeout): cnt = 0 while cnt < timeout * 10: cnt += 1 if self.stoprequest.isSet(): return -1 try: ev = self.event_q.get(timeout=0.1) Logger.log("DetectionStateChangeListenerThread", "get event: {}".format(ev)) if ev[0] == event: return ev[1] except queue.Empty: pass return -1
def dump(): Logger.log("LogcatListener", "---------------------- dump ----------------------") for threadname, th in LogcatListener.WORK_THREADS.items(): Logger.log("LogcatListener::dump", "thread[{}]".format(threadname)) Logger.log( "LogcatListener::dump", " - Last time processing: {} ms ago".format( th.lasttime_update_timer.get_time())) for event_pattern in th.listeners.keys(): Logger.log("LogcatListener::dump", " - pattern '{}'".format(event_pattern)) Logger.log("LogcatListener", "--------------------------------------------------")
def dump(self): self.extra["dump-lock"].acquire() Logger.log(self.get_tag(), "dump called") Logger.log(self.get_tag(), "----------------------------------------------") for msg in self.extra["dump"]: Logger.log("{}::dump".format(self.get_tag()), "\"{}\"".format(msg)) del self.extra["dump"][:] Logger.log(self.get_tag(), "----------------------------------------------") self.extra["dump-lock"].release()
def dump(self): self.extra["dump-lock"].acquire() Logger.log("GoogleMusicApp", "dump called") Logger.log("GoogleMusicApp", "----------------------------------------------") map(lambda x: Logger.log("GoogleMusicApp::dump", "\"{}\"".format(x)), self.extra["dump"]) Logger.log("GoogleMusicApp", "----------------------------------------------") del self.extra["dump"][:] self.extra["dump-lock"].release()
def dump(): Logger.log("LogcatListener", "---------------------- dump ----------------------") for threadname, th in LogcatListener.WORK_THREADS.items(): Logger.log("LogcatListener::dump", "thread[{}]".format(threadname)) for event_pattern in th.listeners.keys(): Logger.log("LogcatListener::dump", " - pattern '{}'".format(event_pattern)) Logger.log("LogcatListener", "--------------------------------------------------")
def reset(self): # reset function must consider the event handling: # if the current state is not None, the active/inactive event might have been sent # and such event should be sent again because it must be same with the case of None -> active # so the active/inactive event needs to be sent again before setting the current state to None active_or_inactive = None with self.event_q.mutex: current_event = self.current_event if current_event: active_or_inactive = DetectionStateListener.Event.ACTIVE \ if current_event[1] == ToneDetector.Event.TONE_DETECTED else \ DetectionStateListener.Event.INACTIVE self.clear() if active_or_inactive: Logger.log( self.get_tag(), "reset and resend the event ({}, 0)".format( active_or_inactive)) self.event_q.put((active_or_inactive, 0))
def run(self): preexec_fn = None if platform.system() == "Windows" else os.setsid cmd = ["adb", "-s", self.serialno, "logcat"] cmd = cmd + ["-b", self.buffername] if self.buffername else cmd Logger.log( "LogcatOutputThread", "threadloop is listening with the command '{}'".format( " ".join(cmd))) self.proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, preexec_fn=preexec_fn) while not self.stoprequest.isSet(): if self.proc.poll() != None: break line = self.proc.stdout.readline() self._handle_logcat_msg(line) if platform.system() != "Windows": os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM)
def run(num_iter=1, serialno=None): num_iter = int(num_iter) Adb.init() Logger.init(Logger.Mode.BOTH_FILE_AND_STDOUT, prefix="quick-start") check_props = { "Device name": "ro.product.model", "Project": "ro.build.product", "ROM": "ro.product.build.fingerprint", } passed = True for tag, prop in check_props.items(): out, err = Adb.execute(["shell", "getprop {}".format(prop)], serialno=serialno) passed &= len(err) == 0 out = out.strip() Logger.log(LOGGER_TAG, "{}: {}".format(tag, out)) Logger.log(LOGGER_TAG, "result: {}".format("passed" if passed else "failed")) Logger.finalize()
def dump(self): self.extra["dump-lock"].acquire() Logger.log("ToneDetectorForDeviceThread", "dump called") Logger.log("ToneDetectorForDeviceThread", "----------------------------------------------") map( lambda msg: Logger.log("ToneDetectorForDeviceThread::dump", "\"{}\"".format(msg)), self.extra["dump"]) del self.extra["dump"][:] Logger.log("ToneDetectorForDeviceThread", "----------------------------------------------") self.extra["dump-lock"].release()
def tone_detected_event_cb(self, event): Logger.log("DetectionStateChangeListenerThread", "tone_detected_event_cb: {}".format(event)) self._handle_event(event)
def tone_detected_event_cb(self, event): Logger.log(self.get_tag(), "tone_detected_event_cb: {}".format(event)) self._handle_event(event)
def evaluate_imagenet_c( model, transform, dataset_dir: str, log_dir: str, corruptions: List[str], batch_size: int, device: str, **kwargs, ) -> None: """ Evaluate corruption accuracy on ImageNet-C. """ if (device != "cpu") and (torch.cuda.device_count() > 1): model = torch.nn.DataParallel(model) log_path = os.path.join(log_dir, os.path.join("imagenet_c_result.csv")) logger = Logger(path=log_path, mode="test") with tqdm.tqdm(total=len(corruptions), ncols=80) as pbar: for i, corruption_type in enumerate(corruptions): accuracies = list() for j in range(1, 6): # imagenet-c dataset is separated to 5 small sets. datasetpath = os.path.join(dataset_dir, corruption_type, str(j)) dataset = torchvision.datasets.ImageFolder(datasetpath, transform) loader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True, ) for x, y in loader: x, y = x.to(device), y.to(device) with torch.autograd.no_grad(): y_predict_std = model(x) stdacc1, stdacc5 = accuracy(y_predict_std, y, topk=(1, 5)) accuracies.append(stdacc1.item()) log_dict = collections.OrderedDict() log_dict["corruption_type"] = corruption_type log_dict["accuracy"] = sum(accuracies) / float(len(accuracies)) logger.log(log_dict) pbar.set_postfix( collections.OrderedDict( corruption_type="{}".format(corruption_type), acc="{}".format(log_dict["accuracy"]), ) ) pbar.update() df = pd.read_csv(log_path) result_dict = dict(zip(df["corruption_type"], df["accuracy"])) mean_corruption_acc = sum(result_dict.values()) / float(len(result_dict)) create_barplot( result_dict, title="mean corruption acc: {0:0.1f}".format(mean_corruption_acc), savepath=os.path.join(log_dir, "plot_result.png"), )
def log(child, msg): Logger.log(child.TAG, msg)
def evaluate_corruption_accuracy( model, dataset_builder, log_dir: str, num_samples: int, corruptions: list, batch_size: int, device: str, **kwargs, ): """ """ if (device != "cpu") and (torch.cuda.device_count() > 1): model = torch.nn.DataParallel(model) log_path = os.path.join(log_dir, os.path.join("corruption_result.csv")) logger = Logger(path=log_path, mode="test") with tqdm.tqdm(total=len(corruptions), ncols=80) as pbar: for i, corruption_type in enumerate(corruptions): dataset = dataset_builder( train=False, normalize=True, num_samples=num_samples, corruption_type=corruption_type, ) loader = torch.utils.data.DataLoader( dataset=dataset, batch_size=batch_size, shuffle=False ) accuracies = list() for x, y in loader: x, y = x.to(device), y.to(device) with torch.autograd.no_grad(): y_predict_std = model(x) stdacc1, stdacc5 = accuracy(y_predict_std, y, topk=(1, 5)) accuracies.append(stdacc1.item()) log_dict = collections.OrderedDict() log_dict["corruption_type"] = corruption_type log_dict["accuracy"] = sum(accuracies) / float(len(accuracies)) logger.log(log_dict) pbar.set_postfix( collections.OrderedDict( corruption_type="{}".format(corruption_type), acc="{}".format(log_dict["accuracy"]), ) ) pbar.update() df = pd.read_csv(log_path) result_dict = dict(zip(df["corruption_type"], df["accuracy"])) mean_corruption_acc = sum(result_dict.values()) / float(len(result_dict)) create_barplot( result_dict, title="mean corruption acc: {0:0.1f}".format(mean_corruption_acc), savepath=os.path.join(log_dir, "plot_result.png"), )
def walk_through(self): if not self.to_top(): Logger.log("GoogleMusicApp", "walk_through failed: unable to go to top activity") self.cache_init = False return False # Get the playcard titles vc = ViewClient(self.device, self.serialno) self.cache_init = True container_key = GoogleMusicApp.CONTAINER_KEY container = [v for v in vc.getViewsById().values() if v.getId() == container_key] container = container[0] if len(container) > 0 else None if container: self.cache["screen-info"] = container.getBounds()[1] self.push_dump("screen-info: {}".format(self.cache["screen-info"])) so = sio.StringIO() vc.traverse(stream=so) lines = so.getvalue().splitlines() play_card_key = GoogleMusicApp.PLAY_CARD_KEY playcards_idices = [idx for idx, line in enumerate(lines) if play_card_key in line] playcards_idices.append(len(lines)) playcards_titles = [] last_idx = playcards_idices[0] li_title_key = GoogleMusicApp.LI_TITLE_KEY for idx in playcards_idices[1:]: li_title_texts = [line for line in lines[last_idx:idx] if li_title_key in line] last_idx = idx if len(li_title_texts) != 1: self.push_dump("li_title_texts has length {}".format(len(li_title_texts))) playcards_titles.append(utf8str(li_title_texts[0].split(li_title_key)[-1].strip())) self.push_dump("playcards_titles.append('{}')".format(playcards_titles[-1])) # Get the track list of each playcard views = [v for v in vc.getViewsById().values() if v.getId() == li_title_key and utf8str(v.getText()) in playcards_titles] self.cache["playcard"] = dict( \ map(lambda v: (utf8str(v.getText()), { "position": v.getCenter() }), views) ) map(lambda v: self.push_dump("view: {}".format(utf8str(v))), views) map(lambda title: self.push_dump("playcard title: '{}'".format(title)), self.cache["playcard"].keys()) if len(views) == 0: self.cache_init = False return False self.cache["shuffle_key"] = playcards_titles[0] self.push_dump("get the shuffle keyword '{}'".format(self.cache["shuffle_key"])) self.touch_playcard(self.cache["shuffle_key"]) time.sleep(1) retry_count = 3 while retry_count > 0: vc.dump() play_pause_header_key = GoogleMusicApp.PLAY_PAUSE_HEADER_KEY play_pause_btn_view = [v for v in vc.getViewsById().values() if v.getId() == play_pause_header_key] play_pause_btn_view = play_pause_btn_view[0] if len(play_pause_btn_view) > 0 else None if play_pause_btn_view: play_desc = utf8str(play_pause_btn_view.getContentDescription()) self.check_play_status = lambda desc: desc == play_desc self.cache["play_pause_btn"] = { "position": play_pause_btn_view.getCenter(), "desc_feat": play_desc } art_pager_key = GoogleMusicApp.ART_PAGER_KEY art_pager_view = [v for v in vc.getViewsById().values() if v.getId() == art_pager_key] art_pager_view = art_pager_view[0] if len(art_pager_view) > 0 else None if not art_pager_view: retry_count -= 1 continue self.cache["art_pager_view"] = { "position": art_pager_view.getCenter() } play_pause_btn_view.touch() break else: self.push_dump("cannot find the play/pause button, retry: {}".format(retry_count)) retry_count -= 1 if retry_count == 0: return False for li_title in self.cache["playcard"].keys(): if li_title == self.cache["shuffle_key"]: continue self.push_dump("now fetching information in the playcard '{}'".format(li_title)) if self.touch_playcard(li_title=li_title): time.sleep(1) self.cache["playcard"][li_title]["songs"] = self._fetch_songs() self.to_top() # Get the information of the control panel retry_count = 3 while self.get_state() != GoogleMusicApp.State.CONTROL_PANEL and retry_count > 0: self.device.touch(*self.cache["art_pager_view"]["position"]) retry_count -= 1 if retry_count == 0 and self.get_state() != GoogleMusicApp.State.CONTROL_PANEL: self.to_top() time.sleep(5) self.touch_playcard(self.cache["shuffle_key"]) time.sleep(2) self.device.touch(*self.cache["play_pause_btn"]["position"]) time.sleep(2) self.device.touch(*self.cache["art_pager_view"]["position"]) time.sleep(2) if self.get_state() != GoogleMusicApp.State.CONTROL_PANEL: self.push_dump("cannot get the information of the control panel") self.cache_init = False return False def find_view_position(vc, res_id): v = [v for v in vc.getViewsById().values() if v.getId() == res_id] if len(v) == 0: return ((-1, -1), (-1, -1)), (-1, -1) return v[0].getBounds(), v[0].getCenter() vc.dump() progress_bounds, progress_pos = find_view_position(vc, GoogleMusicApp.CONTROL_PANEL_PROGRESS_KEY) self.cache["control_panel"] = { "progress": { "position": progress_pos, "xbounds": [progress_bounds[0][0], progress_bounds[1][0]] }, "prev": { "position": find_view_position(vc, GoogleMusicApp.CONTROL_PANEL_PREV_KEY)[1] }, "next": { "position": find_view_position(vc, GoogleMusicApp.CONTROL_PANEL_NEXT_KEY)[1] }, "play_pause": { "position": find_view_position(vc, GoogleMusicApp.CONTROL_PANEL_PLAY_PAUSE_KEY)[1] } } self.control_panel = GMControlPanel(self) self.push_dump("successfully walked through, now back to top") self.to_top() self.cache_init = True return True
def _log(child, msg, tolog): if not tolog: return Logger.log(child.TAG, msg)
def log(msg): Logger.log(GLOBAL["tag"], msg)
def run(self): shared_vars = {"start_time": None, "last_event": None, "last_freq": -1} self.extra = {} self.extra["adb-read-prop-max-elapsed"] = -1 self.extra["freq-cb-max-elapsed"] = -1 self.extra["dump"] = [] self.extra["dump-lock"] = threading.Lock() def freq_cb(msg): line = msg.splitlines()[0] strs = line.split() freq, amp_db = list(map(float, strs[-1].split(","))) the_date, the_time = strs[:2] time_str = the_date + " " + the_time if shared_vars["last_freq"] != freq: self.push_to_dump( \ "the detected freq has been changed from {} to {} Hz".format(shared_vars["last_freq"], freq)) shared_vars["last_freq"] = freq thresh = 10 if self.target_freq else 1 if super(AATAppToneDetectorThread, self).target_detected(freq): self.event_counter += 1 if self.event_counter == 1: shared_vars["start_time"] = time_str if self.event_counter == thresh: if not shared_vars["last_event"] or shared_vars[ "last_event"] != ToneDetector.Event.TONE_DETECTED: Logger.log( self.get_tag(), "send_cb({}, TONE_DETECTED)".format( shared_vars["start_time"])) self.cb((shared_vars["start_time"], ToneDetector.Event.TONE_DETECTED)) shared_vars[ "last_event"] = ToneDetector.Event.TONE_DETECTED else: if self.event_counter > thresh: shared_vars["start_time"] = None self.push_to_dump( "the tone is not detected and the event_counter is over the threshold" ) self.push_to_dump("last_event: \"{}\"".format( shared_vars["last_event"])) if not shared_vars["last_event"] or shared_vars[ "last_event"] != ToneDetector.Event.TONE_MISSING: Logger.log(self.get_tag(), "send_cb({}, TONE_MISSING)".format(time_str)) self.cb((time_str, ToneDetector.Event.TONE_MISSING)) shared_vars["last_event"] = ToneDetector.Event.TONE_MISSING self.event_counter = 0 if self.event_counter <= thresh: self.push_to_dump("event_counter: {}".format( self.event_counter)) # Adb.execute(cmd= \ # ["shell", "am", "broadcast", "-a", "audio.htc.com.intent.print.properties.enable", "--ez", "v", "1"], \ # serialno=self.serialno) from libs.timeutils import TicToc, TimeUtils freq_cb_tictoc = TicToc() adb_tictoc = TicToc() tcount = 0 freq_cb_tictoc.tic() while not self.stoprequest.isSet(): adb_tictoc.tic() msg, _ = Adb.execute(cmd=["shell", "cat", "sdcard/AudioFunctionsDemo-record-prop.txt"], \ serialno=self.serialno, tolog=False) elapsed = adb_tictoc.toc() if tcount == 0: Adb.execute(cmd=["shell", "rm", "-f", "sdcard/AudioFunctionsDemo-record-prop.txt"], \ serialno=self.serialno, tolog=False) if not "," in msg: msg = "0,-30" if elapsed > self.extra["adb-read-prop-max-elapsed"]: self.extra["adb-read-prop-max-elapsed"] = elapsed if "," in msg: msg = msg.replace("\n", "") import datetime msg = "{} {}".format(TimeUtils.now_str(), msg) try: self.push_to_dump("{} (adb-shell elapsed: {} ms)".format( msg, elapsed)) freq_cb(msg) except Exception as e: Logger.log(self.get_tag(), "crashed in freq_cb('{}')".format(msg)) print(e) elapsed = freq_cb_tictoc.toc() if elapsed > self.extra["freq-cb-max-elapsed"]: self.extra["freq-cb-max-elapsed"] = elapsed time.sleep(0.01) tcount += 1 tcount %= 10
def log(self, text): Logger.log("GoogleMusicApp", text)
def log(msg): Logger.log(TAG, msg)
def run(num_iter=1): AudioFunction.init() Logger.init(Logger.Mode.STDOUT) Logger.log(TAG, "delete the existed dump folder...") subprocess.Popen(["rm", "-rf", "./record-dump"], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() audiodump = AudioSignalFrameLogger() databuff = queue.Queue() th_tictoc = TicToc() push_tictoc = TicToc() push_tictoc.extra = { "initialized": False, "max_period": -1, "avg_period": -1, "push_count": 0, "max_snr": None, "min_snr": None, "avg_snr": -1 } def process_buff(): th_tictoc.tic() try: data = databuff.get(timeout=FRAMEMILLIS*.1/1000.) if push_tictoc.extra["initialized"]: elapsed = push_tictoc.toc() push_tictoc.extra["max_period"] = max([push_tictoc.extra["max_period"], elapsed]) push_tictoc.extra["avg_period"] *= push_tictoc.extra["push_count"] push_tictoc.extra["avg_period"] += elapsed push_tictoc.extra["avg_period"] /= float(push_tictoc.extra["push_count"]+1) else: push_tictoc.tic() push_tictoc.extra["initialized"] = True push_tictoc.extra["push_count"] += 1 audiodump.push(name="signal", fs=FS, values=data) nfft = np.ceil(np.log2(data.shape[0])) nfft = int(2**nfft) spectrum = np.abs(fft(data.flatten(), nfft)) audiodump.push(name="spectrum", fs=-1, values=spectrum) spectrum = spectrum[:nfft/2] unit_freq = FS*1./nfft spectrum = map(lambda x: (x[0]*unit_freq, -x[1]), sort_values(-spectrum)) signal_spectrum = filter(lambda x: target_detected(freq=x[0], target_freq=FREQ), spectrum) noise_spectrum = filter(lambda x: not target_detected(freq=x[0], target_freq=FREQ), spectrum) if len(signal_spectrum) > 0 and len(noise_spectrum) > 0: snr = np.mean(map(lambda x: x[1], signal_spectrum)) / np.mean(map(lambda x: x[1], noise_spectrum)) snr = 20*np.log10(snr) if target_detected(freq=spectrum[0][0], target_freq=FREQ): if push_tictoc.extra["max_snr"] == None or push_tictoc.extra["max_snr"][0] < snr: push_tictoc.extra["max_snr"] = [snr, push_tictoc.extra["push_count"]-1] if push_tictoc.extra["min_snr"] == None or push_tictoc.extra["min_snr"][0] > snr: push_tictoc.extra["min_snr"] = [snr, push_tictoc.extra["push_count"]-1] push_tictoc.extra["avg_snr"] *= (push_tictoc.extra["push_count"]-1) push_tictoc.extra["avg_snr"] += snr push_tictoc.extra["avg_snr"] /= float(push_tictoc.extra["push_count"]) sleeptime = max([FRAMEMILLIS - th_tictoc.toc(), 0]) time.sleep(sleeptime * .99/1000.) except queue.Empty: pass def threadloop(): while True: process_buff() def record_cb(indata): databuff.put(indata) record_cmd = RawRecordCommand(config=AudioConfig(fs=FS, ch=1, dtype="float32", cb=record_cb), framemillis=FRAMEMILLIS) AudioFunction.COMMAND.cmd = record_cmd AudioFunction.WORK_THREAD.push(AudioFunction.COMMAND.cmd) Logger.log(TAG, "start recording on the server...") time.sleep(1) Logger.log(TAG, "start processing the data buffers...") th = threading.Thread(target=threadloop) th.daemon = True th.start() time.sleep(10) AudioFunction.stop_audio() Logger.log(TAG, "stop recording on the server...") audiodump.dump(path="./record-dump") Logger.log(TAG, "------------------------ profiling in process_buff ------------------------") Logger.log(TAG, "max period: {}".format(push_tictoc.extra["max_period"])) Logger.log(TAG, "avg period: {}".format(push_tictoc.extra["avg_period"])) Logger.log(TAG, "push count: {}".format(push_tictoc.extra["push_count"])) Logger.log(TAG, "max SNR : {}".format(push_tictoc.extra["max_snr"])) Logger.log(TAG, "min SNR : {}".format(push_tictoc.extra["min_snr"])) Logger.log(TAG, "avg SNR : {}".format(push_tictoc.extra["avg_snr"])) AudioFunction.finalize() Logger.finalize()