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()
