AUDIODATA_EXPORT
char* retrieve_audiodata(AudioDataDB mdatastore, uint32_t id){
if (mdatastore == NULL || id == 0) return NULL;
void *skt = (void*)mdatastore;
char *mdatastr = NULL;
zmq_msg_t cmd_msg, uid_msg, mdata_msg;
uint8_t cmd = 2;
uint32_t uid;
uid = hosttonet32(id);
zmq_msg_init_size(&cmd_msg, sizeof(uint8_t));
memcpy(zmq_msg_data(&cmd_msg), &cmd, sizeof(uint8_t));
zmq_send(skt, &cmd_msg, ZMQ_SNDMORE);
zmq_msg_init_size(&uid_msg, sizeof(uint32_t));
memcpy(zmq_msg_data(&uid_msg), &uid, sizeof(uint32_t));
zmq_send(skt, &uid_msg, 0);
zmq_msg_init(&mdata_msg);
zmq_recv(skt, &mdata_msg, 0);
mdatastr = strdup((char*)zmq_msg_data(&mdata_msg));
zmq_msg_close(&cmd_msg);
zmq_msg_close(&uid_msg);
zmq_msg_close(&mdata_msg);
return mdatastr;
}
int handle_request(void *skt, sqlite3 *db){
char sql[512];
char rowstr[512];
const int len = 512;
char *errstr, *mdata_inline = NULL;
uint8_t cmd, *data = NULL;
uint32_t uid = 0;
int err = 0;
int64_t more;
size_t msg_size, more_size = sizeof(int64_t);
recieve_msg(skt, &msg_size, &more, &more_size, (void**)&data);
if (msg_size != sizeof(uint8_t) || !more){
if (more) flushall_msg_parts(skt);
free(data);
send_empty_msg(skt);
return -1;
}
memcpy(&cmd, data, sizeof(uint8_t));
free(data);
switch (cmd){
case 1: /* insert new entry */
recieve_msg(skt, &msg_size, &more, &more_size, (void**)&mdata_inline);
if (mdata_inline){
uid = insert_db(db, mdata_inline);
free(mdata_inline);
}
syslog(LOG_DEBUG, "assigned uid = %u", uid);
uid = hosttonet32(uid);
send_msg_vsm(skt, &uid, sizeof(uint32_t));
break;
case 2: /* look up id */
rowstr[0] = '\0';
recieve_msg(skt, &msg_size, &more, &more_size, (void**)&data);
if (msg_size != sizeof(uint32_t)){
free(data);
send_empty_msg(skt);
err = -2;
break;
}
memcpy(&uid, data, sizeof(uint32_t));
uid = nettohost32(uid);
char *result = lookup_db(db, uid);
send_msg_data(skt, result, strlen(result)+1, free_fn, NULL);
break;
default:
syslog(LOG_DEBUG, "unrecognized cmd, %u", cmd);
send_empty_msg(skt);
}
if (more)flushall_msg_parts(skt);
return err;
}
int main(int argc, char **argv){
char addr[32];
if (argc < 4){
fprintf(stdout,"not enough args\n");
fprintf(stdout,"usage: prog <auscoutd address> <port> <port>\n");
fprintf(stdout,"address - mock auscoud server address, e.g. \"localhost\"\n");
fprintf(stdout,"port - mock auscoutd server port e.g. 4005\n");
fprintf(stdout,"port - port to recieve init from auscout driver, e.g. 4009\n");
return 0;
}
/* progname <auscoutd address> <auscoutd port> <driver port>*/
const char *auscoutd_address = argv[1];
const int port = atoi(argv[2]);
const int driver_port = atoi(argv[3]);
int subscr_port = port + 2;
int result_port = port + 3;
int table_port = port + 1;
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, table_port);
fprintf(stdout,"register as table with %s\n", addr);
void *ctx = zmq_init(1);
assert(ctx);
assert(register_table(ctx, addr) == 0);
/* skt to recieve number of files to be sent from auscout driver program */
snprintf(addr, 32, "tcp://*:%d", driver_port);
void *prepskt = socket_bind(ctx, ZMQ_PAIR, addr);
assert(prepskt);
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, subscr_port);
void *subscr_skt = socket_connect(ctx, ZMQ_SUB, addr);
assert(subscr_skt);
assert(zmq_setsockopt(subscr_skt, ZMQ_SUBSCRIBE, "phash.", 6) == 0);
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, result_port);
void *result_skt = socket_connect(ctx, ZMQ_REQ, addr);
assert(result_skt);
struct timespec seed_ts;
clock_gettime(CLOCK_REALTIME, &seed_ts);
srand(seed_ts.tv_nsec);
uint8_t cmd, thrdnum, tblnum;
struct timespec start_ts, end_ts, diff_ts;
uint32_t uid, nbframes, count = 0, nbquerys;
void *data;
int64_t more;
size_t msg_size, more_size = sizeof(int64_t);
float cs = 0.05555f;
fprintf(stdout,"\nready to recieve subscription messages from auscoutd ...\n\n");
while (1){
recieve_msg(prepskt, &msg_size, &more, &more_size, &data);
assert(msg_size == sizeof(uint32_t));
memcpy(&nbquerys, data, sizeof(uint32_t));
free(data);
fprintf(stdout,"expecting %d querys\n\n", nbquerys);
clock_gettime(CLOCK_MONOTONIC, &start_ts);
count = 0;
do {
/* recieve topic */
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
free(data);
/* recieve cmd */
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&cmd, data, sizeof(uint8_t));
free(data);
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&nbframes, data, sizeof(uint32_t));
nbframes = nettohost32(nbframes);
free(data);
/* recieve hash */
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
free(data);
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&thrdnum, data, sizeof(uint8_t));
free(data);
recieve_msg(subscr_skt, &msg_size, &more, &more_size, &data);
memcpy(&uid, data, sizeof(uint32_t));
uid = nettohost32(uid);
free(data);
if (cmd == 1){
/* recieved lookup */
uid = 0; /* send back random integer id*/
cs = 0.5555;
fprintf(stdout,"(%d) lookup: %u frames\n",count,nbframes);
fprintf(stdout," reply : thrdnum %u | uid %u | cs %f\n\n",thrdnum,uid,cs);
uid = hosttonet32(uid);
cs = hosttonetf(cs);
sendmore_msg_vsm(result_skt, &thrdnum, sizeof(uint8_t));
sendmore_msg_vsm(result_skt, &uid, sizeof(uint32_t));
send_msg_vsm(result_skt, &cs, sizeof(float));
recieve_msg(result_skt, &msg_size, &more, &more_size, &data);
free(data);
} else if (cmd == 2){
tblnum = thrdnum;
/* recieved submission */
fprintf(stdout,"(%d) submit: %u frames | %u table\n",count,nbframes,tblnum);
fprintf(stdout," no reply\n\n");
}
fprintf(stdout,"**************************************\n");
} while (++count < nbquerys);
clock_gettime(CLOCK_MONOTONIC, &end_ts);
diff_ts = diff_timespec(start_ts, end_ts);
unsigned long long total_ull = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
float total_secs = (float)total_ull/1000000000.0f;
float rate = (float)nbquerys/total_secs;
fprintf(stdout,"recieved %d querys in %f secs - %f querys/sec\n",\
nbquerys, total_secs, rate);
}
zmq_close(subscr_skt);
zmq_close(result_skt);
zmq_close(prepskt);
zmq_term(ctx);
return 0;
}
/* aux message to worker thread to a message */
static int pull_message(int thrn, void *pullskt, void *resultskt){
uint8_t cmd, perms = 0, threadnum, table_n, **toggles = NULL;
uint32_t nbframes, id = 0;
void *hash = NULL, *data = NULL;
int i, err;
int64_t more;
size_t msg_size, more_size = sizeof(int64_t);
float cs = -1.0f;
/* pull cmd msg part */
recieve_msg(pullskt, &msg_size, &more, &more_size, &data);
if (msg_size != sizeof(uint8_t) || !more){
if (more) flushall_msg_parts(pullskt);
free(data);
return -1;
}
memcpy(&cmd, data, sizeof(uint8_t));
free(data);
/* pull nbframes msg part */
recieve_msg(pullskt, &msg_size, &more, &more_size, &data);
if (msg_size != sizeof(uint32_t) || !more){
if (more) flushall_msg_parts(pullskt);
free(data);
return -2;
}
memcpy(&nbframes, data, sizeof(uint32_t));
nbframes = nettohost32(nbframes);
free(data);
/* pull hash msg part */
recieve_msg(pullskt, &msg_size, &more, &more_size, &hash);
if (msg_size != nbframes*sizeof(uint32_t) || !more){
syslog(LOG_DEBUG,"WORKER%d: inconsistent hash msg part size = %d", thrn, msg_size);
if (more) flushall_msg_parts(pullskt);
free(hash);
return -3;
}
/* recieve threadnum (for cmd== 1) or table_num (for cmd == 2)*/
recieve_msg(pullskt, &msg_size, &more, &more_size, (void**)&data);
if (msg_size != sizeof(uint8_t) || !more){
syslog(LOG_DEBUG,"WORKER%d: inconsistent threadnum msg size, %d", thrn, msg_size);
if (more) flushall_msg_parts(pullskt);
free(data);
free(hash);
return -4;
}
memcpy(&threadnum, data, sizeof(uint8_t));
free(data);
recieve_msg(pullskt, &msg_size, &more, &more_size, &data);
if (msg_size != sizeof(uint32_t)){
syslog(LOG_DEBUG,"WORKER%d: inconsistent uid msg size = %d", thrn, msg_size);
free(data);
free(hash);
return -5;
}
memcpy(&id, data, sizeof(uint32_t));
id = nettohost32(id);
free(data);
/* de-serialization */
for (i=0;i<nbframes;i++){
((uint32_t*)hash)[i] = nettohost32(((uint32_t*)hash)[i]);
}
if (more){
toggles = retrieve_extra(pullskt, nbframes, &perms);
}
err = execute_command(thrn, cmd, hash, toggles, perms,nbframes, threadnum, &id, &cs);
if (err < 0){
syslog(LOG_DEBUG,"WORKER%d: unable to execute command, err=%d", err);
}
if (toggles) {
for (i = 0;i<nbframes;i++){
free(toggles[i]);
}
free(toggles);
toggles = NULL;
}
free(hash);
hash = NULL;
if (cs >= GlobalArgs.threshold){
syslog(LOG_DEBUG,"WORKER%d: %u threadnum, %f cs, %u id", thrn, threadnum, cs, id);
id = hosttonet32(id);
cs = hosttonetf(cs);
send_results(resultskt, threadnum, id, cs);
}
return 0;
}
void* query_thread(void *arg){
ThrParam *thrparam = (ThrParam*)arg;
void *ctx = thrparam->ctx;
char *mdatastr = thrparam->mdatastr;
uint32_t **hashes = thrparam->hashes;
uint32_t *pnbframes = thrparam->nbframes;
unsigned int nbfiles = thrparam->nbfiles;
uint8_t thrn = thrparam->thrn;
uint8_t cmd = thrparam->cmd;
void *skt = zmq_socket(ctx, ZMQ_REQ);
assert(skt);
fprintf(stdout,"thrn%d: connect to %s\n", thrn, thrparam->address);
assert(zmq_connect(skt, thrparam->address)==0);
unsigned int i,j;
void *data;
int64_t more;
size_t msg_size, more_size=sizeof(int64_t);
struct timespec t1_ts, t2_ts, diff_ts;
unsigned long long latency, sum_ull = 0ULL;
if (cmd == 1){ /* queries */
for (i=0;i<nbfiles;i++){
clock_gettime(CLOCK_MONOTONIC, &t1_ts);
sendmore_msg_vsm(skt, &cmd, sizeof(uint8_t));
uint32_t snbframes = hosttonet32(pnbframes[i]);
sendmore_msg_vsm(skt, &snbframes, sizeof(uint32_t));
send_msg_data(skt, hashes[i], pnbframes[i]*sizeof(uint32_t), free_fn, NULL);
recieve_msg(skt, &msg_size, &more, &more_size, &data);
clock_gettime(CLOCK_MONOTONIC, &t2_ts);
diff_ts = diff_timespec(t1_ts, t2_ts);
latency = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
sum_ull += latency;
fprintf(stdout,"thrd%d: query %u frames, recv:\"%s\" in %llu nsecs\n",\
thrn,pnbframes[i],(char*)data, latency);
free(data);
/* simulate interarrival */
unsigned int pause = Arr; /* = next_arrival(Arr);*/
usleep(1000*pause);
}
} else if (cmd == 2){ /* submissions */
for (i=0;i<nbfiles;i++){
clock_gettime(CLOCK_MONOTONIC, &t1_ts);
sendmore_msg_vsm(skt, &cmd, sizeof(uint8_t));
uint32_t snbframes = hosttonet32(pnbframes[i]);
sendmore_msg_vsm(skt, &snbframes, sizeof(uint32_t));
sendmore_msg_data(skt, hashes[i], pnbframes[i]*sizeof(uint32_t), free_fn, NULL);
send_msg_data(skt, mdatastr, strlen(mdatastr)+1, NULL, NULL);
recieve_msg(skt, &msg_size, &more, &more_size, &data);
assert(msg_size == sizeof(uint32_t));
uint32_t uid;
memcpy(&uid, data, sizeof(uint32_t));
uid = nettohost32(uid);
clock_gettime(CLOCK_MONOTONIC, &t2_ts);
diff_ts = diff_timespec(t1_ts, t2_ts);
latency = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
sum_ull += latency;
fprintf(stdout,"thr%d: submit %u frames, recv %u=uid in %llu nsecs\n",\
thrn, pnbframes[i], uid, latency);
/* simulate interarrival */
unsigned int pause = Arr; /*next_arrival(Arr);*/
usleep(1000*pause);
free(data);
}
}
free(thrparam);
zmq_close(skt);
/* return the sum of latency's */
void *ptr = malloc(sizeof(unsigned long long));
assert(ptr);
memcpy(ptr, &sum_ull, sizeof(unsigned long long));
pthread_exit(ptr);
}
void SendThread::doSend(){
quint8 cmd;
if (mode == QUERY_MODE) {
cmd = 1;
} else if (mode == SUBMIT_MODE){
cmd = 2;
} else{
return;
}
QString delimStr(delim);
emit activatedProgress(true);
emit changedRange(0, fileList.size());
emit changedLevel(0);
int error;
float *sigbuf = new float[1<<24];
const unsigned int buflen = 1<<24;
quint32 nbframes = 0, snbframes = 0, id = 0;
char *data = NULL;
char mdata_inlinestr[512];
AudioHashStInfo hash_st;
hash_st.sr = 0;
int index = 0;
AudioMetaData mdata;
init_mdata(&mdata);
foreach(QString currentFile, fileList){
emit appendedText(tr("looking up ") + currentFile);
unsigned int tmpbuflen = buflen;
char *file = currentFile.toLocal8Bit().data();
float *buf = readaudio(file, 6000, sigbuf, &tmpbuflen, nbsecs, &mdata, &error);
if (!buf){
QString errorString = QString("unable to read audio: err code %1").arg(error);
qDebug() << "could not read file: " << errorString;
emit postedError(errorString);
continue;
}
quint32 *hash = NULL;
int res = audiohash(buf,&hash,NULL,NULL,NULL,&nbframes,NULL,NULL,\
tmpbuflen,0,6000,&hash_st);
if (res < 0){
QString errorString = QString("unable to extract a hash");
emit postedError(errorString);
qDebug() << "could not get hash: " << errorString.toUtf8().data();
if (buf != sigbuf) ph_free(buf);
continue;
}
try {
zmq::message_t cmdmsg(&cmd, sizeof(quint8), NULL);
snbframes = hosttonet32(nbframes);
zmq::message_t framesmsg(&snbframes, sizeof(quint32), NULL);
zmq::message_t hashmsg(hash, nbframes*sizeof(quint32), free_func);
skt->send(cmdmsg, ZMQ_SNDMORE);
skt->send(framesmsg, ZMQ_SNDMORE);
if (cmd == 1){ //query
skt->send(hashmsg, 0);
} else { //query
skt->send(hashmsg, ZMQ_SNDMORE);
metadata_to_inlinestr(&mdata, mdata_inlinestr, 512);
zmq::message_t metadata_msg(mdata_inlinestr, strlen(mdata_inlinestr)+1, NULL);
skt->send(metadata_msg, 0);
}
zmq::message_t respmsg;
skt->recv(&respmsg, 0);
data = (char*)respmsg.data();
QString retdString(data);
if (cmd == 1){
QStringList resultList = retdString.split(delimStr);
int i = 0;
foreach (QString resultStr, resultList){
if (i < fields.size()){
emit appendedText(fields[i] + ": " + resultStr);
}
i++;
}
resultList.clear();
} else if (cmd == 2){
if (respmsg.size() != sizeof(quint32)) {
QString errorString = QString("recieved msg of incorrectsize, %1").arg(respmsg.size());
emit postedError(errorString);
if (buf != sigbuf) ph_free(buf);
continue;
}
memcpy(&id, data, sizeof(quint32));
id = nettohost32(id);
QString line = QString("assigned id = %1").arg(id);
emit appendedText(line);
}
} catch (zmq::error_t err){
