int main(int argc, char *argv[])
{
init_mdata();
init_adata();
printf("Loading file 'bytecode'\n");
pc_t* pc = pc_new("bytecode");
while (pc_safe(pc))
{
printf("ADDR: %x, OP: %x\n", pc->address, pc->line->op);
pc_inc(pc, 1);
pc_update(pc);
}
pc_inc(pc, -1);
pc_branch(pc, 1);
pc_update(pc);
while (pc_safe(pc))
{
printf("ADDR: %x, OP: %x\n", pc->address, pc->line->op);
pc_inc(pc, 1);
pc_update(pc);
}
pc_return(pc);
pc_update(pc);
printf("ADDR: %x, OP: %x\n", pc->address, pc->line->op);
pc_del(pc);
return 0;
}
JNIEXPORT jfloatArray JNICALL Java_org_phash_AudioHash_readAudio
(JNIEnv *env, jclass cl, jstring name, jint sr, jfloat nbsecs, jobject mdataObj){
jboolean iscopy;
const char *filename = env->GetStringUTFChars(name, &iscopy);
int error;
unsigned int buflen = 0;
AudioMetaData mdata;
init_mdata(&mdata);
float *buf = readaudio(filename, sr, NULL, &buflen, nbsecs, &mdata, &error);
if (buf == NULL){
free_mdata(&mdata);
env->ReleaseStringUTFChars(name, filename);
return NULL;
}
jfloatArray buf2 = env->NewFloatArray((jint)buflen);
env->SetFloatArrayRegion(buf2, 0, buflen, (jfloat*)buf);
// get fieldIds
jclass mdataclass = env->GetObjectClass(mdataObj);
jfieldID composerfield = env->GetFieldID(mdataclass, "composer" , "Ljava/lang/String;" );
jfieldID title1field = env->GetFieldID(mdataclass, "title1" , "Ljava/lang/String;" );
jfieldID title2field = env->GetFieldID(mdataclass, "title2" , "Ljava/lang/String;" );
jfieldID title3field = env->GetFieldID(mdataclass, "title3" , "Ljava/lang/String;" );
jfieldID tpe1field = env->GetFieldID(mdataclass, "tpe1" , "Ljava/lang/String;" );
jfieldID tpe2field = env->GetFieldID(mdataclass, "tpe2" , "Ljava/lang/String;" );
jfieldID tpe3field = env->GetFieldID(mdataclass, "tpe3" , "Ljava/lang/String;" );
jfieldID tpe4field = env->GetFieldID(mdataclass, "tpe4" , "Ljava/lang/String;" );
jfieldID datefield = env->GetFieldID(mdataclass, "date" , "Ljava/lang/String;" );
jfieldID albumfield = env->GetFieldID(mdataclass, "album" , "Ljava/lang/String;" );
jfieldID genrefield = env->GetFieldID(mdataclass, "genre" , "Ljava/lang/String;" );
jfieldID yearfield = env->GetFieldID(mdataclass, "year" , "I");
jfieldID durationfield = env->GetFieldID(mdataclass, "duration" , "I");
jfieldID partofsetfield = env->GetFieldID(mdataclass, "partofset", "I");
// set AudioMetaData fields
if (composerfield != 0) env->SetObjectField(mdataObj, composerfield, env->NewStringUTF(mdata.composer));
if (title1field != 0) env->SetObjectField(mdataObj, title1field, env->NewStringUTF(mdata.title1));
if (title2field != 0) env->SetObjectField(mdataObj, title2field, env->NewStringUTF(mdata.title2));
if (title3field != 0) env->SetObjectField(mdataObj, title3field, env->NewStringUTF(mdata.title3));
if (tpe1field != 0) env->SetObjectField(mdataObj, tpe1field, env->NewStringUTF(mdata.tpe1));
if (tpe2field != 0) env->SetObjectField(mdataObj, tpe2field, env->NewStringUTF(mdata.tpe2));
if (tpe3field != 0) env->SetObjectField(mdataObj, tpe3field, env->NewStringUTF(mdata.tpe3));
if (tpe4field != 0) env->SetObjectField(mdataObj, tpe4field, env->NewStringUTF(mdata.tpe4));
if (datefield != 0) env->SetObjectField(mdataObj, datefield, env->NewStringUTF(mdata.date));
if (albumfield != 0) env->SetObjectField(mdataObj, albumfield, env->NewStringUTF(mdata.album));
if (genrefield != 0) env->SetObjectField(mdataObj, genrefield, env->NewStringUTF(mdata.genre));
if (yearfield != 0) env->SetIntField(mdataObj , yearfield, mdata.year);
if (durationfield != 0) env->SetIntField(mdataObj , durationfield, mdata.duration);
if (partofsetfield != 0)env->SetIntField(mdataObj , partofsetfield, mdata.partofset);
audiodata_free(buf);
free_mdata(&mdata);
env->ReleaseStringUTFChars(name, filename);
return buf2;
}
int main(int argc, char** argv)
{
ASSERT(argc > 1, "Specify a bytecode file in the first and only argument, please\n");
init_mdata(); // Initalize the instruction defs
init_adata();
init_ins_def();
rt_t* runtime = proc_init(argv[1]); // Initalize process
proc_run(runtime); // Execute runtime
proc_clean(runtime); // Once `proc_run` returns, clean
// what sort of mess it made.
return 0;
}
AUDIODATA_EXPORT
void free_mdata(AudioMetaData *mdata){
if (mdata == NULL) return;
if (mdata->composer) free(mdata->composer);
if (mdata->title1) free(mdata->title1);
if (mdata->title2) free(mdata->title2);
if (mdata->title3) free(mdata->title3);
if (mdata->tpe1) free(mdata->tpe1);
if (mdata->tpe2) free(mdata->tpe2);
if (mdata->tpe3) free(mdata->tpe3);
if (mdata->tpe4) free(mdata->tpe4);
if (mdata->date) free(mdata->date);
if (mdata->album) free(mdata->album);
if (mdata->genre) free(mdata->genre);
init_mdata(mdata);
return;
}
AUDIODATA_EXPORT
float* readaudio(const char *filename, const int sr, float *sigbuf, unsigned int *buflen,\
const float nbsecs, AudioMetaData *mdata, int *error)
{
long orig_sr;
unsigned int orig_length = 0;
float *inbuffer = NULL;
*error = PHERR_SUCCESS;
if (filename == NULL || buflen == NULL) {
*error = PHERR_NULLARG;
return NULL;
}
if (mdata) init_mdata(mdata);
const char *suffix = strrchr(filename, '.');
if (*suffix != '\0' && !strncasecmp(suffix+1, "mp3",3)) {
#ifdef HAVE_MPG123
inbuffer = readaudio_mp3(filename, &orig_sr, &orig_length, nbsecs, mdata, error);
#endif /* HAVE_MPG123 */
} else {
inbuffer = readaudio_snd(filename, &orig_sr, &orig_length, nbsecs, mdata, error);
}
if (inbuffer == NULL){
return NULL;
}
/* if no data extracted for title, use the file name */
if (mdata && mdata->title2 == NULL){
char *name = strrchr(filename, '/');
if (name == NULL) name = strchr(filename, '\\');
if (name) mdata->title2 = strdup(name+1);
}
/* resample float array */
/* set desired sr ratio */
double sr_ratio = (double)(sr)/(double)orig_sr;
if (src_is_valid_ratio(sr_ratio) == 0){
*error = PHERR_BADSR;
free(inbuffer);
return NULL;
}
/* allocate output buffer for conversion */
unsigned int outbufferlength = sr_ratio*(orig_length);
float *outbuffer = NULL;
if (sigbuf && outbufferlength < *buflen){
outbuffer = sigbuf;
} else {
outbuffer = (float*)malloc(outbufferlength*sizeof(float));
}
if (!outbuffer){
free(inbuffer);
*error = PHERR_NOBUFALLOCD;
return NULL;
}
SRC_STATE *src_state = src_new(SRC_LINEAR, 1, error);
if (!src_state){
*error = PHERR_SRCCONTXT;
free(inbuffer);
if (outbuffer != sigbuf) free(outbuffer);
return NULL;
}
SRC_DATA src_data;
src_data.data_in = inbuffer;
src_data.data_out = outbuffer;
src_data.input_frames = orig_length;
src_data.output_frames = outbufferlength;
src_data.end_of_input = SF_TRUE;
src_data.src_ratio = sr_ratio;
/* sample rate conversion */
*error = src_process(src_state, &src_data);
if (*error){
*error = PHERR_SRCPROC;
free(inbuffer);
if (outbuffer != sigbuf) free(outbuffer);
src_delete(src_state);
return NULL;
}
*buflen = outbufferlength;
src_delete(src_state);
free(inbuffer);
return outbuffer;
}
static
float *readaudio_snd(const char *filename, long *sr, unsigned int *buflen,\
const float nbsecs, AudioMetaData *mdata, int *error){
SF_INFO sf_info;
sf_info.format=0;
SNDFILE *sndfile = sf_open(filename, SFM_READ, &sf_info);
if (sndfile == NULL){
*error = PHERR_SNDFILEOPEN;
return NULL;
}
/* normalize */
sf_command(sndfile, SFC_SET_NORM_FLOAT, NULL, SF_TRUE);
if (mdata){
init_mdata(mdata);
/* extract metadata from file */
const char *tmp = sf_get_string(sndfile, SF_STR_TITLE);
mdata->title2 = (tmp) ? strdup(tmp): NULL;
tmp = sf_get_string(sndfile,SF_STR_ARTIST);
mdata->tpe1= (tmp) ? strdup(tmp) : NULL;
mdata->composer = (tmp) ? strdup(tmp) : NULL;
tmp = sf_get_string(sndfile,SF_STR_DATE);
mdata->date = (tmp) ? strdup(tmp):NULL;
}
*sr = (long)sf_info.samplerate;
/*allocate input buffer for signal*/
unsigned int src_frames = (nbsecs <= 0) ? sf_info.frames : (nbsecs*sf_info.samplerate);
src_frames = (sf_info.frames < src_frames) ? sf_info.frames : src_frames;
float *inbuf = (float*)malloc(src_frames*sf_info.channels*sizeof(float));
if (inbuf == NULL){
*error = PHERR_MEMALLOC;
return NULL;
}
/*read frames */
sf_count_t cnt_frames = sf_readf_float(sndfile, inbuf, src_frames);
float *buf = (float*)malloc(cnt_frames*sizeof(float));
if (buf == NULL){
*error = PHERR_MEMALLOC;
return NULL;
}
*buflen = cnt_frames;
/*average across all channels*/
int i,j,indx=0;
for (i=0;i<cnt_frames*sf_info.channels;i+=sf_info.channels){
buf[indx] = 0;
for (j=0;j<sf_info.channels;j++){
buf[indx] += inbuf[i+j];
}
buf[indx++] /= sf_info.channels;
}
free(inbuf);
return buf;
}
float* readaudio_mp3(const char *filename,long *sr, unsigned int *buflen,\
const float nbsecs, AudioMetaData *mdata, int *error){
mpg123_handle *m;
int ret = 0;
mpg123_id3v1 *v1 = NULL;
mpg123_id3v2 *v2 = NULL;
if ((ret = mpg123_init()) != MPG123_OK || ((m = mpg123_new(NULL,&ret)) == NULL)|| \
(ret = mpg123_open(m, filename)) != MPG123_OK){
*error = (ret != 0) ? ret : PHERR_MP3NEW;
return NULL;
}
/*turn off logging */
mpg123_param(m, MPG123_ADD_FLAGS, MPG123_QUIET, 0);
off_t totalsamples;
mpg123_scan(m);
totalsamples = mpg123_length(m);
if (totalsamples <= 0){
*error = PHERR_NOSAMPLES;
return NULL;
}
int meta = mpg123_meta_check(m);
if (mdata)init_mdata(mdata);
if (mdata && (meta & MPG123_ID3) && mpg123_id3(m, &v1, &v2) == MPG123_OK){
if (v2){
get_v2_data(v2, mdata);
} else if (v1){
get_v1_data(v1, mdata);
}
}
int channels, encoding;
if (mpg123_getformat(m, sr, &channels, &encoding) != MPG123_OK){
*error = PHERR_NOFORMAT;
return NULL;
}
mpg123_format_none(m);
mpg123_format(m, *sr, channels, encoding);
if (channels <= 0 || encoding <= 0){
*error = PHERR_NOENCODING;
return NULL;
}
size_t decbuflen = mpg123_outblock(m);
if (decbuflen == 0){
/* take a guess */
decbuflen = 1<<16;
}
unsigned char *decbuf = (unsigned char*)malloc(decbuflen);
if (decbuf == NULL){
*error = PHERR_MEMALLOC;
return NULL;
}
unsigned int nbsamples = (nbsecs <= 0) ? totalsamples : nbsecs*(*sr);
nbsamples = (nbsamples <= totalsamples) ? nbsamples : totalsamples;
size_t i, j, index = 0, done;
float *buffer = (float*)malloc(nbsamples*sizeof(float));
if (buffer == NULL){
*error = PHERR_MEMALLOC;
return NULL;
}
*buflen = nbsamples;
do {
ret = mpg123_read(m, decbuf, decbuflen, &done);
switch (encoding) {
case MPG123_ENC_SIGNED_16 :
for (i = 0; i < done/sizeof(short); i+=channels){
buffer[index] = 0.0f;
for (j = 0; j < channels ; j++){
buffer[index] += (float)(((short*)decbuf)[i+j])/(float)SHRT_MAX;
}
buffer[index++] /= channels;
if (index >= nbsamples) break;
}
break;
case MPG123_ENC_SIGNED_8:
for (i = 0; i < done/sizeof(char); i+=channels){
buffer[index] = 0.0f;
for (j = 0; j < channels ; j++){
buffer[index] += (float)(((char*)decbuf)[i+j])/(float)SCHAR_MAX;
}
buffer[index++] /= channels;
if (index >= nbsamples) break;
}
break;
case MPG123_ENC_FLOAT_32:
for (i = 0; i < done/sizeof(float); i+=channels){
buffer[index] = 0.0f;
for (j = 0; j < channels; j++){
buffer[index] += ((float*)decbuf)[i+j];
}
buffer[index++] /= channels;
if (index >= nbsamples) break;
}
break;
default:
done = 0;
}
} while (ret == MPG123_OK && index < nbsamples);
if (ret != MPG123_DONE && ret != MPG123_OK && index < nbsamples){
free(buffer);
*error = ret;
buffer=NULL;
}
free(decbuf);
mpg123_close(m);
mpg123_delete(m);
mpg123_exit();
return buffer;
}
int main(int argc, char **argv){
char addr[32];
if (argc < 8){
printf("not enough input args\n");
printf("usage: progname <cmd> <nbthreads> <server address> <nbquerys>\n");
printf(" cmd - 1 for query, 2 for file submission\n");
printf(" nbthreads - number of driver threads\n");
printf(" arr - ave inter-arrival time (millisecs)\n");
printf(" server address - address of auscoutd, e.g. \"localhost\"\n");
printf(" sink address - e.g. tcp://localhost:port\n");
printf(" port - port of the auscoutd server, e.g. 4005\n");
printf(" nbquerys - total number queries to submit\n");
return 0;
}
/*args [cmd | nbthreads | arr | server address | nbquerys ] */
const int cmd = (uint8_t)atoi(argv[1]);
const int nbthreads = atoi(argv[2]);
Arr = atoi(argv[3]);
char *auscoutd_address = argv[4];
char *ausink_address = argv[5];
const int port = atoi(argv[6]);
const int nbquerys = atoi(argv[7]);
snprintf(addr, 32, "tcp://%s:%d", auscoutd_address, port);
void *ctx = zmq_init(1);
assert(ctx);
unsigned int nb_files_per_thread = nbquerys/nbthreads;
unsigned int nb_files_last_thread = nbquerys%nbthreads;
fprintf(stdout,"\nfiles per thread %u\n" , nb_files_per_thread);
fprintf(stdout, "files in last thread %u\n", nb_files_last_thread);
fprintf(stdout, "nb threads %d\n\n" , nbthreads);
uint32_t **hashes = (uint32_t**)malloc(nbquerys*sizeof(uint32_t*));
uint32_t *ptrNbframes = (uint32_t*)malloc(nbquerys*sizeof(uint32_t));;
/* socket to send init signal to ausink */
void *prepskt = socket_connect(ctx, ZMQ_PAIR, ausink_address);
assert(prepskt);
struct timespec seed;
clock_gettime(CLOCK_REALTIME, &seed);
srand(seed.tv_nsec);
struct timespec start_ts, end_ts;
AudioMetaData phonymdata;
init_mdata(&phonymdata);
phonymdata.composer = "composer";
phonymdata.title2 = "title";
phonymdata.tpe1 = "performer";
phonymdata.date = "date";
phonymdata.year = 2010;
phonymdata.album = "album";
phonymdata.genre = "genre";
phonymdata.duration = 1000000;
phonymdata.partofset = 1;
char mdata_inlinestr[512];
metadata_to_inlinestr(&phonymdata, mdata_inlinestr, 512);
int i, err;
if (cmd == 1 || cmd == 2){ /* querys */
for (i = 0;i < nbquerys;i++){
uint32_t nbframes = rand()%12500;
uint32_t *hash = (uint32_t*)malloc(nbframes*sizeof(uint32_t));
assert(hash);
hashes[i] = hash;
ptrNbframes[i] = nbframes;
}
/* start of send time*/
clock_gettime(CLOCK_MONOTONIC, &start_ts);
/* send init signal with number of files sending to ausc sink */
uint32_t nb = nbquerys;
send_msg_vsm(prepskt, &nb, sizeof(uint32_t));
fprintf(stdout, "send to auscoutd\n");
ThrParam *thrparam;
pthread_t *thrs = (pthread_t*)malloc((nbthreads+1)*sizeof(pthread_t));
assert(thrs);
for (i=0;i<nbthreads;i++){
thrparam = (ThrParam*)malloc(sizeof(ThrParam));
assert(thrparam);
thrparam->ctx = ctx;
thrparam->cmd = cmd;
thrparam->thrn = i;
thrparam->mdatastr = mdata_inlinestr;
thrparam->nbfiles = nb_files_per_thread;
thrparam->address = addr;
thrparam->hashes = hashes + i*nb_files_per_thread;
thrparam->nbframes = ptrNbframes + i*nb_files_per_thread;
assert(pthread_create(&thrs[i], NULL, query_thread, thrparam) == 0);
}
if (nb_files_last_thread){
thrparam = (ThrParam*)malloc(sizeof(ThrParam));
assert(thrparam);
thrparam->ctx = ctx;
thrparam->cmd = cmd;
thrparam->thrn = nbthreads;
thrparam->mdatastr = mdata_inlinestr;
thrparam->nbfiles = nb_files_last_thread;
thrparam->address = addr;
thrparam->hashes = hashes + nbthreads*nb_files_per_thread;
thrparam->nbframes = ptrNbframes + nbthreads*nb_files_per_thread;
assert(pthread_create(&thrs[nbthreads], NULL, query_thread, thrparam) == 0);
}
/* wait for threads */
unsigned long long sum_ull, *ptr_ave = NULL;
for (i=0;i < nbthreads;i++){
pthread_join(thrs[i], (void**)&ptr_ave);
sum_ull += *ptr_ave;
}
if (nb_files_last_thread){
pthread_join(thrs[nbthreads], (void**)&ptr_ave);
sum_ull += *ptr_ave;
}
/* end of sending */
clock_gettime(CLOCK_MONOTONIC, &end_ts);
struct timespec total_ts = diff_timespec(start_ts, end_ts);
unsigned long long total = 1000000000*total_ts.tv_sec + total_ts.tv_nsec;
float total_secs = (float)total/1000000000.0f;
float ave_latency = (float)sum_ull/(float)nbquerys/1000000000.0f;
float rate = (float)nbquerys/total_secs;
fprintf(stdout,"ave latency, %f secs\n", ave_latency);
fprintf(stdout,"rate: %f querys/sec\n", rate);
fprintf(stdout,"total time, %f secs\n", total_secs);
} else {
fprintf(stdout,"unrecognized cmd, %u\n", cmd);
}
zmq_close(prepskt);
zmq_term(ctx);
return 0;
}
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){
